Type aliases
AcceptedPredicateTypes
AcceptedPredicateTypes: function | string | Array<string>
ActionCache
ActionCache: object & object | object
ActionCacheQueueItem
ActionCacheQueueItem: object
Type declaration
-
-
allowErrors: boolean
-
allowPending: boolean
-
-
-
invalidate: boolean
-
isContextDependency: boolean
-
isDependencyOf: CachedAction | undefined
-
visitedDependants: HashSet | undefined
-
visitedDependencies: HashSet | undefined
AddItemAttableGraphNode
Add
ItemAttableGraphNode: DynamicGraphNode<T, P, S, D, V, "addItemAt", AddItemAtOperation, AddItemAttableNodeType<T, P, S, D, V>>
AddItemAttableNodeDefinition
Add
ItemAttableNodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "addItemAt", AddItemAtOperation, AddItemAttableNodeType<T, P, S, D, V>>
BranchDefinition
BranchDefinition: object
Type declaration
-
-
-
param: string | undefined
CachedActionId
CachedActionId: number
CallArgumentMap
CallArgumentMap: object
CallableGraphNode
Callable
GraphNode: DynamicGraphNode<T, P, S, D, V, "call", CallOperation, CallableNodeType<T, P, S, D, V>>
CallableNodeDefinition
Callable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "call", CallOperation, CallableNodeType<T, P, S, D, V>>
Callback
Callback: function
Type declaration
-
- (err: any, response: T, body: any): void
-
Parameters
-
err: any
-
response: T
-
body: any
Returns void
ClearableGraphNode
Clearable
GraphNode: DynamicGraphNode<T, P, S, D, V, "clear", ClearOperation, ClearableNodeType<T, P, S, D, V>>
ClearableNodeDefinition
Clearable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "clear", ClearOperation, ClearableNodeType<T, P, S, D, V>>
ContainerGraphNode
Container
GraphNode: DynamicGraphNode<T, P, S, D, V, "getChild", GetChildOperation, ContainerNodeType<T, P, S, D, V>>
ContainerNodeDefinition
Container
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "getChild", GetChildOperation, ContainerNodeType<T, P, S, D, V>>
ContainsableGraphNode
Containsable
GraphNode: DynamicGraphNode<T, P, S, D, V, "contains", ContainsOperation, ContainsableNodeType<T, P, S, D, V>>
ContainsableNodeDefinition
Containsable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "contains", ContainsOperation, ContainsableNodeType<T, P, S, D, V>>
ContextId
ContextId: string
ContextName
ContextName: string
ContextValues
ContextValues: object
ContextValuesDefinitions
ContextValuesDefinitions: object
ContextWithPathKey
Context
WithPathKey: Context & object
DeferNodeFallbackGenerator
DeferNodeFallbackGenerator: function
DisposeCallback
DisposeCallback: function
DisposeCallback
DisposeCallback: function
DisposeRequest
DisposeRequest: function
DynamicNodeType
Dynamic
NodeType: StatelessNodeType<T, P, V, M, O> | StatefulNodeType<T, P, S, D, V, M, O>
EmitterCallback
EmitterCallback: function
ErrorFallbackGenerator
ErrorFallbackGenerator: function
EvaluableGraphNode
Evaluable
GraphNode: DynamicGraphNode<T, P, S, D, V, "evaluate", EvaluateOperation, EvaluableNodeType<T, P, S, D, V>>
EvaluableNodeDefinition
Evaluable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "evaluate", EvaluateOperation, EvaluableNodeType<T, P, S, D, V>>
EventRedispatcher
EventRedispatcher: function
ExclusiveSliceBounds
ExclusiveSliceBounds: object
FieldSetDefinition
FieldSetDefinition: object
GenericFactory
GenericFactory: function
GraphNodeWithIsPending
Graph
NodeWithIsPending: DynamicGraphNode<T, P, S, D, V, "isPending", IsPendingOperation, NodeTypeWithIsPending<T, P, S, D, V>>
GraphNodeWithIsUpdating
Graph
NodeWithIsUpdating: DynamicGraphNode<T, P, S, D, V, "isUpdating", IsUpdatingOperation, NodeTypeWithIsUpdating<T, P, S, D, V>>
GraphNodeWithRemoveItem
Graph
NodeWithRemoveItem: DynamicGraphNode<T, P, S, D, V, "removeItem", RemoveItemOperation, NodeTypeWithRemoveItem<T, P, S, D, V>>
HashSet
HashSet: Set<string>
HistoryWithId
HistoryWithId: History & object
InclusiveSliceBounds
InclusiveSliceBounds: object
InitableGraphNode
Initable
GraphNode: DynamicGraphNode<T, P, S, D, V, "init", InitOperation, InitableNodeType<T, P, S, D, V>>
InitableNodeDefinition
Initable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "init", InitOperation, InitableNodeType<T, P, S, D, V>>
InvalidTypeErrorOptions
InvalidTypeErrorOptions: object
Type declaration
-
Optional expected?: any | Array<any>
-
received: any
InvalidateOnNodeCallback
InvalidateOnNodeCallback: function
IterableGraphNode
Iterable
GraphNode: DynamicGraphNode<T, P, S, D, V, "iterate", IterateOperation, IterableNodeType<T, P, S, D, V>>
IterableNodeDefinition
Iterable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "iterate", IterateOperation, IterableNodeType<T, P, S, D, V>>
KeyMatcher
KeyMatcher: function
Type declaration
-
-
Parameters
Returns boolean
LengthtableGraphNode
Lengthtable
GraphNode: DynamicGraphNode<T, P, S, D, V, "length", LengthOperation, LengthtableNodeType<T, P, S, D, V>>
LengthtableNodeDefinition
Lengthtable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "length", LengthOperation, LengthtableNodeType<T, P, S, D, V>>
ListGraphNode
List
GraphNode: DynamicGraphNode<T, P, S, D, V, "getItems", GetItemsOperation, ListNodeType<T, P, S, D, V>>
ListNodeDefinition
List
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "getItems", GetItemsOperation, ListNodeType<T, P, S, D, V>>
LocationParamsEncoding
LocationParamsEncoding: "base64" | "json"
LogSink
LogSink: function
Type declaration
-
- (...args: Array<any>): void
MiddlewareTransformer
MiddlewareTransformer: function
ModuleDependencies
ModuleDependencies: object
ModuleFactory
ModuleFactory: function
ModuleRequirements
ModuleRequirements: object
MusterEventName
MusterEventName: string
MusterEventPayload
MusterEventPayload: any
MusterOperationDefinition
MusterTypeMap
MusterTypeMap: object
MusterTypeName
MusterTypeName: string
NamedFnArgs
NamedFnArgs: object
NodeData
NodeData: object
NodeDefinitionCallback
NodeDefinitionCallback: function
NodeDefinitionWithIsPending
Node
DefinitionWithIsPending: DynamicNodeDefinition<T, P, S, D, V, "isPending", IsPendingOperation, NodeTypeWithIsPending<T, P, S, D, V>>
NodeDefinitionWithIsUpdating
Node
DefinitionWithIsUpdating: DynamicNodeDefinition<T, P, S, D, V, "isUpdating", IsUpdatingOperation, NodeTypeWithIsUpdating<T, P, S, D, V>>
NodeDefinitionWithRemoveItem
Node
DefinitionWithRemoveItem: DynamicNodeDefinition<T, P, S, D, V, "removeItem", RemoveItemOperation, NodeTypeWithRemoveItem<T, P, S, D, V>>
NodeLikeCallArgumentArray
NodeLikeCallArgumentMap
NodeLikeCallArgumentMap: object
NodeName
NodeName: string
NodeProperties
NodeProperties: object
NodeTransformer
NodeTransformer: function
NodeTypeMap
NodeTypeMap: object
OnNodeCallback
OnNodeCallback: function
OperationFactory
OperationFactory: function
OperationHandler
Operation
Handler: StatelessOperationHandler<T, P, V, M, O> | StatefulOperationHandler<T, P, S, D, V, M, O>
OperationHandlerDefinition
OperationId
OperationId: string
OperationName
OperationName: string
OperationProperties
OperationProperties: object
OperationTypeMap
OperationTypeMap: object
PendingFallbackGenerator
PendingFallbackGenerator: function
PoptableGraphNode
Poptable
GraphNode: DynamicGraphNode<T, P, S, D, V, "pop", PopOperation, PoptableNodeType<T, P, S, D, V>>
PoptableNodeDefinition
Poptable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "pop", PopOperation, PoptableNodeType<T, P, S, D, V>>
PushtableGraphNode
Pushtable
GraphNode: DynamicGraphNode<T, P, S, D, V, "push", PushOperation, PushtableNodeType<T, P, S, D, V>>
PushtableNodeDefinition
Pushtable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "push", PushOperation, PushtableNodeType<T, P, S, D, V>>
QueriesSnapshot
QueriesSnapshot: object
QueryPartCallback
QueryPartCallback: function
QuerySetCallback
QuerySetCallback: function
QuerySetChildWithPath
QuerySetChildWithPath: object
RelativeSliceBounds
RelativeSliceBounds: object
RemoveItemAttableGraphNode
Remove
ItemAttableGraphNode: DynamicGraphNode<T, P, S, D, V, "removeItemAt", RemoveItemAtOperation, RemoveItemAttableNodeType<T, P, S, D, V>>
RemoveItemAttableNodeDefinition
Remove
ItemAttableNodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "removeItemAt", RemoveItemAtOperation, RemoveItemAttableNodeType<T, P, S, D, V>>
RemoveItemAttableNodeType
RequestGraphNode
Request
GraphNode: DynamicGraphNode<T, P, S, D, V, "request", RequestOperation, RequestNodeType<T, P, S, D, V>>
RequestMetadata
RequestMetadata: object
RequestNodeDefinition
Request
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "request", RequestOperation, RequestNodeType<T, P, S, D, V>>
ResettableGraphNode
Resettable
GraphNode: DynamicGraphNode<T, P, S, D, V, "reset", ResetOperation, ResettableNodeType<T, P, S, D, V>>
ResettableNodeDefinition
Resettable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "reset", ResetOperation, ResettableNodeType<T, P, S, D, V>>
ResolvableGraphNode
Resolvable
GraphNode: DynamicGraphNode<T, P, S, D, V, "resolve", ResolveOperation, ResolvableNodeType<T, P, S, D, V>>
ResolvableNodeDefinition
Resolvable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "resolve", ResolveOperation, ResolvableNodeType<T, P, S, D, V>>
ResponseAssembler
ResponseAssembler: function
ResponseFactory
ResponseFactory: function
ResponsePartAssembler
ResponsePartAssembler: function
ResponseTransformer
ResponseTransformer: function
ResultableGraphNode
Resultable
GraphNode: DynamicGraphNode<T, P, S, D, V, "result", ResultOperation<any>, ResultableNodeType<T, P, S, D, V>>
ResultableNodeDefinition
Resultable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "result", ResultOperation<any>, ResultableNodeType<T, P, S, D, V>>
SchedulerFactory
SchedulerFactory: function
SerializableQuerySetChild
SerializedActionCache
SerializedActionCache: object & object | object
SerializedGraphOperation
SerializedGraphOperation: object
Type declaration
-
$operation: O["name"]
-
data: P
-
id: string
SerializedMusterTypeData
SerializedMusterTypeData: any
SerializedNodeDefinition
SerializedNodeDefinition: object
SerializedNodeProperties
SerializedNodeProperties: any
SerializedNodeType
SerializedNodeType: object
Type declaration
-
operations: Array<string>
SerializedNodeTypesMap
SerializedNodeTypesMap: object
SerializedOperationProperties
SerializedOperationProperties: any
SerializedPrimitive
SerializedPrimitive: string | number | boolean | null | undefined
SerializedPrimitive
SerializedPrimitive: string | number | boolean | null | undefined
SerializedSubscription
SerializedSubscription: object
SettableGraphNode
Settable
GraphNode: DynamicGraphNode<T, P, S, D, V, "set", SetOperation, SettableNodeType<T, P, S, D, V>>
SettableNodeDefinition
Settable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "set", SetOperation, SettableNodeType<T, P, S, D, V>>
SetterFactory
SetterFactory: function
ShapeFields
ShapeFields: object
ShifttableGraphNode
Shifttable
GraphNode: DynamicGraphNode<T, P, S, D, V, "shift", ShiftOperation, ShifttableNodeType<T, P, S, D, V>>
ShifttableNodeDefinition
Shifttable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "shift", ShiftOperation, ShifttableNodeType<T, P, S, D, V>>
SortValue
SortValue: null | undefined | boolean | string | number | Date
SteppableGraphNode
Steppable
GraphNode: DynamicGraphNode<T, P, S, D, V, "step", StepOperation<any>, SteppableNodeType<T, P, S, D, V>>
SteppableNodeDefinition
Steppable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "step", StepOperation<any>, SteppableNodeType<T, P, S, D, V>>
StoreSubscribe
StoreSubscribe: function
StreamFactory
StreamFactory: function
StreamUpdateCallback
StreamUpdateCallback: function
SupportsRemoveItemsGraphNode
Supports
RemoveItemsGraphNode: DynamicGraphNode<T, P, S, D, V, "removeItems", RemoveItemsOperation, SupportsRemoveItemsNodeType<T, P, S, D, V>>
SupportsRemoveItemsNodeDefinition
Supports
RemoveItemsNodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "removeItems", RemoveItemsOperation, SupportsRemoveItemsNodeType<T, P, S, D, V>>
SupportsRemoveItemsNodeType
TransformerGraphNode
Transformer
GraphNode: DynamicGraphNode<T, P, S, D, V, "transformItems", TransformItemsOperation, TransformerNodeType<T, P, S, D, V>>
TransformerNodeDefinition
Transformer
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "transformItems", TransformItemsOperation, TransformerNodeType<T, P, S, D, V>>
TransformerNodeDefinition
UnshifttableGraphNode
Unshifttable
GraphNode: DynamicGraphNode<T, P, S, D, V, "unshift", UnshiftOperation, UnshifttableNodeType<T, P, S, D, V>>
UnshifttableNodeDefinition
Unshifttable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "unshift", UnshiftOperation, UnshifttableNodeType<T, P, S, D, V>>
UnsubscribeCallback
UnsubscribeCallback: function
UpdateCallback
UpdateCallback: function
UpdateCallback
UpdateCallback: function
ValueStreamFactory
ValueStreamFactory: function
ValueUpdater
ValueUpdater: Partial<object> | function
XhrResult
XhrResult: object | object
Variables
Const ActionNodeType
Action
NodeType: StatelessNodeType<"action", ActionNodeProperties> = createNodeType<'action',ActionNodeProperties>('action', {serialize: false,deserialize: false,shape: {body: types.saveHash(types.func),},operations: {call: {cacheable: false,getDependencies(properties: ActionNodeProperties,operation: CallOperation,): Array<NodeDependency> {const { args } = operation.properties;if (!args) return [];if (isCallArgumentArray(args)) {return args.map((arg) => ({target: arg,until: untilIsDataNode,once: true,}));}return Object.keys(args).map((name) => ({target: args[name],until: untilIsDataNode,once: true,}));},run(node: ActionNode,operation: CallOperation,argValues: Array<DataNode>,): GraphNode | NodeDefinition {const { body } = node.definition.properties;const { args } = operation.properties;const unwrappedArgs = argValues.map((argValue) => valueOf(argValue));let result: any;if (!args) {result = body();} else if (isCallArgumentArray(args)) {// Handle array of argumentsresult = body(...unwrappedArgs);} else {// Handle named argumentsconst argNames = Object.keys(args);result = body(fromPairs(zip(argNames, unwrappedArgs)));}if (isProxiedNode(result)) {return getProxiedNodeValue(result);}if (isGraphNode(result)) {return result;}if (isNodeDefinition(result)) {return withScopeFrom(node, result);}if (isGenerator(result)) {const generatorResult = stepNext(result, []);return isGraphNode(generatorResult)? generatorResult: withScopeFrom(node, generatorResult);}return withScopeFrom(node, value(result));},},},})
Const AddItemAtNodeType
Add
ItemAtNodeType: StatefulNodeType<"add-item-at", AddItemAtNodeProperties, AddItemAtNodeState, __type> = createNodeType<'add-item-at', AddItemAtNodeProperties, AddItemAtNodeState, {}>('add-item-at', {shape: {index: graphTypes.nodeDefinition,item: graphTypes.nodeDefinition,target: graphTypes.nodeDefinition,},state: {memoized: types.saveHash(types.func),},getInitialState() {return {memoized: once((target: GraphNode, item: NodeDefinition, index: number) =>createGraphAction(target, addItemAtOperation(item, index)),),};},operations: {evaluate: {cacheable: false,getDependencies({ target, index }: AddItemAtNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsAddItemAtOperation,},{target: index,until: untilIntegerValueIndex,},];},run(node: AddItemAtNode,options: never,[target, index]: [GraphNode, ValueNode<number>],context: never,state: AddItemAtNodeState,): GraphAction {const { item } = node.definition.properties;return state.memoized(target, item, index.definition.properties.value);},},},})
Const AddItemAtOperationType
Add
ItemAtOperationType: OperationType<"addItemAt", AddItemAtProperties> = createOperationType<'addItemAt', AddItemAtProperties>('addItemAt', {cacheable: false,shape: {index: types.number,value: graphTypes.nodeDefinition,},})
Const AddNodeType
Add
NodeType: StatelessNodeType<"add", AddNodeProperties> = createNodeType<'add',AddNodeProperties>('add', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: AddNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: untilNumberValueNode(AddNodeType, 'operand'),}));},run(node: AddNode, options: never, operands: Array<ValueNode<number>>): NodeDefinition {const operandValues = operands.map((operand) => operand.definition.properties.value);return value(operandValues.reduce((total, value) => total + value, 0));},},},})
Const AndNodeType
And
NodeType: StatelessNodeType<"and", AndNodeProperties> = createNodeType<'and',AndNodeProperties>('and', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: AndNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('And node operands must resolve to value() nodes', {expected: ValueNodeType,received: node.definition,});},},}));},run(node: AndNode, options: never, operands: Array<ValueNode<any>>): NodeDefinition {return value(operands.every((operand) => Boolean(operand.definition.properties.value)));},},},})
Const ApplyNodeType
Apply
NodeType: StatelessNodeType<"apply", ApplyNodeProperties> = createNodeType<'apply',ApplyNodeProperties>('apply', {shape: {target: types.oneOfType<NodeDefinition | GraphNode>([graphTypes.nodeDefinition,graphTypes.graphNode,]),args: types.oneOfType([types.arrayOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])),types.objectOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])),]),},operations: {evaluate: {getDependencies({ target }: ApplyNodeProperties): [NodeDependency] {return [{target,until: untilSupportsCallOperation,},];},run(node: ApplyNode, options: never, [subjectNode]: [CallableGraphNode]): GraphAction {const { args } = node.definition.properties;let argNodes: any;if (isCallArgumentArray(args)) {argNodes = args.map((arg) => (isGraphNode(arg) ? arg : withScopeFrom(node, arg)));} else {argNodes = mapValues(args, (arg) => (isGraphNode(arg) ? arg : withScopeFrom(node, arg)));}return createGraphAction(subjectNode, callOperation(argNodes));},},},})
Const ApplyTransformsNodeType
Apply
TransformsNodeType: StatelessNodeType<"applyTransforms", ApplyTransformsNodeProperties> = createNodeType<'applyTransforms', ApplyTransformsNodeProperties>('applyTransforms', {shape: {target: graphTypes.nodeDefinition,transforms: types.arrayOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])),},operations: {getItems: {getDependencies({ target }: ApplyTransformsNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsGetItemOperation,},];},run(node: ApplyTransformsNode,operation: GetItemsOperation,[source]: [GraphNode],): GraphAction {const { transforms } = node.definition.properties;const scopedTransforms = [...transforms, ...operation.properties.transforms].map((transform) => (isNodeDefinition(transform) ? withScopeFrom(node, transform) : transform),);return createGraphAction(source, getItemsOperation(scopedTransforms));},},},})
Const ArithmeticNodeTypes
Arithmetic
NodeTypes: Array<NodeType> = [AddNodeType,CeilNodeType,ClampNodeType,DivideNodeType,FloorNodeType,MaxNodeType,MinNodeType,ModNodeType,MultiplyNodeType,PowNodeType,RoundNodeType,SqrtNodeType,SubtractNodeType,]
Const ArrayListNodeType
Array
ListNodeType: StatefulNodeType<"arrayList", ArrayListNodeProperties, ArrayListNodeState, ArrayListNodeData> = createNodeType<'arrayList', ArrayListNodeProperties, ArrayListNodeState, ArrayListNodeData>('arrayList',{state: {items: types.optional(graphTypes.nodeDefinition),poppedItem: types.optional(graphTypes.graphNode),shiftedItem: types.optional(graphTypes.graphNode),unshiftedItem: types.optional(graphTypes.graphNode),removeItems: types.objectOf(graphTypes.nodeDefinition),},shape: {items: types.arrayOf(graphTypes.nodeDefinition),},getInitialState(): ArrayListNodeState {return {items: undefined,poppedItem: undefined,shiftedItem: undefined,unshiftedItem: undefined,removeItems: {},};},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,) {if (this.getState().items) return;this.retain();this.setState((state) => ({...state,items: nodeList(node.definition.properties.items.map((item) => withUniqueId(node, item))),}));},operations: {addItemAt: {cacheable: false,run(): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,operation: AddItemAtOperation,): void {const { index, value } = operation.properties;const clonedItems = this.getState().items!.properties.items.slice(0);const sanitizedIndex = Math.min(clonedItems.length - 1, index);clonedItems.splice(sanitizedIndex, 0, withUniqueId(node, value));this.setState((state) => ({...state,items: nodeList(clonedItems),}));},},clear: {cacheable: false,run(): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,): void {this.setState((state) => ({...state,items: nodeList([]),}));},},evaluate: {run(node: ArrayListNode,options: never,dependencies: Array<never>,context: Array<never>,state: ArrayListNodeState,): NodeDefinition {return state.items!;},},length: {run(node: ArrayListNode,options: never,dependencies: Array<never>,context: Array<never>,state: ArrayListNodeState,): NodeDefinition {return value(state.items!.properties.items.length);},},contains: {run(node: ArrayListNode,operation: ContainsOperation,dependencies: Array<never>,contextDependencies: Array<never>,state: ArrayListNodeState,): NodeDefinition {const { item: otherItem, comparator } = operation.properties;return resolve(state.items!.properties.items.map((item) => ({target: apply([item, otherItem], comparator),until: untilBooleanValuePredicate,})),(results: Array<ValueNode<boolean>>) =>value(results.some((item) => item.definition.properties.value)),);},},pop: {cacheable: false,run(node: ArrayListNode,options: never,dependencies: Array<never>,context: Array<never>,state: ArrayListNodeState,): GraphNode {return state.poppedItem!;},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,): void {const items = this.getState().items!.properties.items;if (items.length === 0) {this.setState((state) => ({...state,poppedItem: withScopeFrom(node, nil()),}));return;}const remaining = items.slice(0);const last = remaining.pop()!;this.setState((state) => ({...state,items: nodeList(remaining),poppedItem: last,}));},},push: {cacheable: false,run(): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,operation: PushOperation,): void {const { items } = this.getState().items!.properties;this.setState((state) => ({...state,items: nodeList([...items, withUniqueId(node, operation.properties.value)]),}));},},removeItem: {cacheable: false,run(): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,operation: RemoveItemOperation,): void {const { items } = this.getState().items!.properties;const clonedItems = items.slice(0);const itemIndex = clonedItems.findIndex((item) => item.definition.properties.id === operation.properties.id,);if (itemIndex === -1) return;clonedItems.splice(itemIndex, 1);this.setState((state) => ({...state,items: nodeList(clonedItems),}));},},removeItemAt: {cacheable: false,run(): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,operation: RemoveItemAtOperation,): void {const { index } = operation.properties;const { items } = this.getState().items!.properties;if (!Number.isInteger(index) || index < 0 || index > items.length - 1) return;this.setState((state) => ({...state,items: nodeList([...items.slice(0, operation.properties.index),...items.slice(operation.properties.index + 1),]),}));},},removeItems: {cacheable: false,run(node: ArrayListNode,operation: RemoveItemsOperation,dependencies: Array<never>,contextDependencies: Array<never>,state: ArrayListNodeState,): NodeDefinition {const { removeItems } = state;return removeItems[operation.id] || ok();},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,operation: RemoveItemsOperation,): void {const { predicate } = operation.properties;const { items } = this.getState().items!.properties;if (items.length === 0) {return;}this.setState((prevState) =>operation.id in prevState.removeItems? prevState: {...prevState,removeItems: {...prevState.removeItems,[operation.id]: resolve(items.map((item) => ({target: apply([item], predicate),until: untilBooleanValuePredicate,})),(processedResults: Array<ValueNode<boolean>>) => {this.setState((prevState) => {// If the array list has been mutated since this operation was subscribed, there// may now be some items which haven't been tested. These should NOT be removed.const { items: currentItems } = this.getState();const updatedItems = currentItems!.properties.items.filter((item, index) => {const processedItemIndex = items.findIndex((processedItem) => processedItem.id === item.id,);if (processedItemIndex === -1) {return true;}const result = processedResults[processedItemIndex];return !result.definition.properties.value;},);return {...prevState,items: nodeList(updatedItems),removeItems: omit(prevState.removeItems, operation.id),};});return ok();},),},},);},},shift: {cacheable: false,run(node: ArrayListNode,options: never,dependencies: Array<never>,context: Array<never>,state: ArrayListNodeState,): GraphNode {return state.shiftedItem!;},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,): void {const { items } = this.getState().items!.properties;if (!items || items.length === 0) {this.setState((state) => ({...state,shiftedItem: withScopeFrom(node, nil()),}));return;}const remaining = items.slice(0);const last = remaining.shift()!;this.setState((state) => ({...state,items: nodeList(remaining),shiftedItem: last,}));},},unshift: {cacheable: false,run(): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,operation: UnshiftOperation,): void {const { items } = this.getState().items!.properties;this.setState((state) => ({...state,items: nodeList([withUniqueId(node, operation.properties.value), ...items]),}));},},},},)
Const ArrayNodeType
Array
NodeType: StatelessNodeType<"array", ArrayNodeProperties> = createNodeType<'array',ArrayNodeProperties>('array', {shape: {items: types.arrayOf(graphTypes.nodeDefinition),},operations: {getItems: {run(node: ArrayNode, operation: GetItemsOperation): NodeDefinition | GraphAction {const items = toGraphNodesWithIndices(node, node.definition.properties.items);const itemsNode = nodeList(items);return operation.properties.transforms.length === 0? itemsNode: createGraphAction(withScopeFrom(node, itemsNode), operation);},},iterate: {run(node: ArrayNode): NodeDefinition {const items = toGraphNodesWithIndices(node, node.definition.properties.items);if (items.length === 0) {return nil();}return iteratorResult(items[0], nodeList(items.slice(1)));},},length: {run(node: ArrayNode): NodeDefinition {return value(node.definition.properties.items.length);},},contains: {run(node: ArrayNode, operation: ContainsOperation): NodeDefinition {const items = toGraphNodesWithIndices(node, node.definition.properties.items);const { item: otherItem, comparator } = operation.properties;return resolve(items.map((item) => ({target: apply([item, otherItem], comparator),until: untilBooleanValueNodeItem,})),(results: Array<ValueNode<boolean>>) =>value(results.some((item) => item.definition.properties.value)),);},},},})
Const ArrayReducerNodeType
Array
ReducerNodeType: StatelessNodeType<"arrayReducer", ArrayReducerNodeProperties> = createNodeType('arrayReducer', {operations: {init: {run(): ValueNodeDefinition<ArrayReducerAccumulator> {return value([]);},},step: {run(node: ArrayReducerNode,operation: StepOperation<ArrayReducerAccumulator>,): ValueNodeDefinition<ArrayReducerAccumulator> {const { acc, item } = operation.properties;return value([...acc, item]);},},result: {run(node: ArrayReducerNode,operation: ResultOperation<ArrayReducerAccumulator>,): ValueNodeDefinition<NodeListNodeDefinition> {return value(nodeList(operation.properties.acc));},},},})
Const BatchRequestsMiddlewareNodeType
Batch
RequestsMiddlewareNodeType: StatefulNodeType<"batch-requests-middleware", BatchRequestsMiddlewareNodeProperties, BatchRequestsMiddlewareNodeState, BatchRequestsMiddlewareNodeData> = createNodeType<'batch-requests-middleware',BatchRequestsMiddlewareNodeProperties,BatchRequestsMiddlewareNodeState,BatchRequestsMiddlewareNodeData>('batch-requests-middleware', {shape: {},state: {batcherResults: types.objectOf(graphTypes.nodeDefinition),},getInitialState() {return {batcherResults: {},};},onSubscribe() {this.setData({batchers: new Map(),});},onUnsubscribe() {const { batchers } = this.getData();if (!batchers) return;for (const batcher of batchers.values()) {batcher.dispose();}},operations: {request: {run(node: BatchRequestsMiddlewareNode,operation: RequestOperation,dependencies: never,context: never,state: BatchRequestsMiddlewareNodeState,): NodeDefinition | GraphNode {const { metadata, next, query } = operation.properties;if (!next) {return error('Missing `next` middleware.');}if (!isQuerySetNodeDefinition(query)) {return withScopeFrom(next, traverse(next.definition, requestOperation(query, metadata)));}return state.batcherResults[query.properties.root.id] || pending();},onSubscribe(this: NodeExecutionContext<BatchRequestsMiddlewareNodeState,BatchRequestsMiddlewareNodeData>,node: BatchRequestsMiddlewareNode,operation: RequestOperation,): void {const { metadata, next, query } = operation.properties;// Check if the query is of a supported type or the next middleware is undefinedif (!next || !isQuerySetNodeDefinition(query)) return;const batchers = this.getData().batchers!;const { children, root } = query.properties;let currentBatcher = batchers.get(root.id);if (!currentBatcher) {currentBatcher = new RequestBatcher((node, operation, callback) => node.scope.store.subscribe(node, operation, callback),next,root,(value) => {this.setState((state) => ({...state,batcherResults: {...state.batcherResults,[root.id]: value,},}));},);batchers.set(root.id, currentBatcher);}this.setState((state) => ({...state,batcherResults: omit(state.batcherResults, root.id),}));currentBatcher.setRequest(children as Array<SerializableQuerySetChild>, metadata);},onUnsubscribe(this: NodeExecutionContext<BatchRequestsMiddlewareNodeState,BatchRequestsMiddlewareNodeData>,node: BatchRequestsMiddlewareNode,operation: RequestOperation,): void {const { query } = operation.properties;if (!isQuerySetNodeDefinition(query)) return;const { root } = query.properties;this.setState((state) => ({...state,batcherResults: omit(state.batcherResults, root.id),}));},},},})
Const BrowserNodeTypes
Browser
NodeTypes: Array<NodeType> = [LocationNodeType,LocationDataNodeType,LocationPathNodeType,]
Const CACHED_INSTANCES
CACHED_
INSTANCES: GraphOperation<string, ResolveProperties, ResolveProperties, OperationType<"resolve", ResolveProperties, ResolveProperties>>[] = [// TODO: Cleanup the `as ResolveProperties`createGraphOperation(ResolveOperationType, {until: undefined,allowErrors: false,allowPending: false,acceptNil: false,} as ResolveProperties),createGraphOperation(ResolveOperationType, {until: undefined,allowErrors: false,allowPending: false,acceptNil: true,} as ResolveProperties),createGraphOperation(ResolveOperationType, {until: undefined,allowErrors: false,allowPending: true,acceptNil: false,} as ResolveProperties),createGraphOperation(ResolveOperationType, {until: undefined,allowErrors: false,allowPending: true,acceptNil: true,} as ResolveProperties),createGraphOperation(ResolveOperationType, {until: undefined,allowErrors: true,allowPending: false,acceptNil: false,} as ResolveProperties),createGraphOperation(ResolveOperationType, {until: undefined,allowErrors: true,allowPending: false,acceptNil: true,} as ResolveProperties),createGraphOperation(ResolveOperationType, {until: undefined,allowErrors: true,allowPending: true,acceptNil: false,} as ResolveProperties),createGraphOperation(ResolveOperationType, {until: undefined,allowErrors: true,allowPending: true,acceptNil: true,} as ResolveProperties),]
Const CONTEXT
CONTEXT: unique symbol = Symbol.for('muster::CONTEXT')
Const CallNodeType
Call
NodeType: StatefulNodeType<"call", CallNodeProperties, CallNodeState, CallNodeData> = createNodeType<'call', CallNodeProperties, CallNodeState, CallNodeData>('call', {shape: {target: graphTypes.nodeDefinition,args: types.optional(types.oneOfType([types.arrayOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])),types.objectOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])),]),),},state: {currentValue: types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode]),},getInitialState() {return {currentValue: pending(),};},operations: {evaluate: {cacheable: false,run(node: CallNode,options: never,dependencies: never,context: never,state: CallNodeState,): GraphNode | NodeDefinition {return state.currentValue;},onSubscribe(this: NodeExecutionContext<CallNodeState, CallNodeData>, node: CallNode): void {const { target } = node.definition.properties;const updateState = ([result]: [GraphNode]) => {this.setState({ currentValue: result });return result;};this.setState({currentValue: resolve([{ target, until: untilSupportsCallOperation }], ([targetNode]) => {const { args } = node.definition.properties;let argNodes: CallArgumentMap | CallArgumentArray | undefined;if (args) {argNodes = isCallArgumentMap(args)? mapValues(args, (arg) => (isGraphNode(arg) ? arg : withScopeFrom(node, arg))): args.map((arg) => (isGraphNode(arg) ? arg : withScopeFrom(node, arg)));}const traverseTarget = traverse(targetNode.definition, callOperation(argNodes));return resolve([{ target: withScopeFrom(targetNode, traverseTarget) }], updateState);}),});},},},})
Const CallOperationType
Call
OperationType: OperationType<"call", CallProperties> = createOperationType<'call',CallProperties>('call', {cacheable: false,shape: {args: types.optional(types.oneOfType([types.arrayOf(types.oneOfType([graphTypes.graphNode, graphTypes.nodeDefinition])),types.objectOf(types.oneOfType([graphTypes.graphNode, graphTypes.nodeDefinition])),]),),},})
Const CatchErrorNodeType
Catch
ErrorNodeType: StaticNodeType<"catch-error", CatchErrorNodeProperties> = createNodeType<'catch-error', CatchErrorNodeProperties>('catch-error', {deserialize: false,serialize: false,shape: {fallbackGenerator: types.saveHash(types.func),target: graphTypes.nodeDefinition,},})
Const CeilNodeType
Ceil
NodeType: StatelessNodeType<"ceil", CeilNodeProperties> = createNodeType<'ceil',CeilNodeProperties>('ceil', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: CeilNodeProperties): Array<NodeDependency> {return [{ target, until: untilNumberValueNode(CeilNodeType, 'target') }];},run(node: CeilNode, options: never, [target]: [ValueNode<number>]): NodeDefinition {return toValue(Math.ceil(target.definition.properties.value));},},},})
Const CharAtNodeType
Char
AtNodeType: StatelessNodeType<"char-at", CharAtNodeProperties> = createNodeType<'char-at',CharAtNodeProperties>('char-at', {shape: {index: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ index, subject }: CharAtNodeProperties): Array<NodeDependency> {return [{target: index,until: untilPositiveIntegerValueNode(CharAtNodeType, 'index'),},{target: subject,acceptNil: true,until: untilStringValueNode(CharAtNodeType, 'subject'),},];},run(node: CharAtNode,options: never,[index, subject]: [ValueNode<number>, ValueNode<string>],): NodeDefinition {if (NilNodeType.is(subject)) return nil();const indexValue = index.definition.properties.value;const content = subject.definition.properties.value;if (indexValue >= content.length) return nil();return value(content.charAt(indexValue));},},},})
Const ChooseNodeType
Choose
NodeType: StatelessNodeType<"choose", ChooseNodeProperties> = createNodeType<'choose',ChooseNodeProperties>('choose', {shape: {options: types.arrayOf(graphTypes.nodeDefinition),fallback: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ options }: ChooseNodeProperties): Array<NodeDependency> {return options.map((option) => ({target: option.properties.pattern,until: untilConditionIsValueNode,}));},run(node: ChooseNode, operation: never, conditions: Array<ValueNode<any>>): NodeDefinition {const { fallback, options } = node.definition.properties;const matchIndex = conditions.findIndex((condition) =>Boolean(condition.definition.properties.value),);if (matchIndex === -1) {return fallback.properties.value;}return options[matchIndex].properties.value;},},},})
Const ClampNodeType
Clamp
NodeType: StatelessNodeType<"clamp", ClampNodeProperties> = createNodeType<'clamp',ClampNodeProperties>('clamp', {shape: {max: graphTypes.nodeDefinition,min: graphTypes.nodeDefinition,value: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ max, min, value }: ClampNodeProperties): Array<NodeDependency> {return [{ target: max, until: untilNumberValueNode(ClampNodeType, 'max') },{ target: min, until: untilNumberValueNode(ClampNodeType, 'min') },{ target: value, until: untilNumberValueNode(ClampNodeType, 'value') },];},run(node: ClampNode,options: never,[max, min, value]: [ValueNode<number>, ValueNode<number>, ValueNode<number>],): NodeDefinition {const maxNumber = max.definition.properties.value;const minNumber = min.definition.properties.value;const valueNumber = value.definition.properties.value;return toValue(Math.min(Math.max(valueNumber, minNumber), maxNumber));},},},})
Const ClearNodeType
Clear
NodeType: StatelessNodeType<"clear", ClearNodeProperties> = createNodeType<'clear',ClearNodeProperties>('clear', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {cacheable: false,getDependencies({ target }: ClearNodeProperties): [NodeDependency] {return [{target,until: untilSupportsClearOperation,},];},run(node: ClearNode,options: never,[target]: [GraphNode, ValueNode<number>],context: never,): GraphAction {return createGraphAction(target, clearOperation());},},},})
Const CollectionNodeTypes
Collection
NodeTypes: Array<NodeType> = [...KeysNodeTypes,...TransformsNodeTypes,AddItemAtNodeType,ApplyTransformsNodeType,ArrayNodeType,ArrayListNodeType,ArrayReducerNodeType,ContainsNodeType,HeadNodeType,ItemWithIdNodeType,IterateNodeType,NodeListNodeType,PopNodeType,PushNodeType,ReduceNodeType,RemoveItemNodeType,RemoveItemAtNodeType,RemoveItemsNodeType,ShiftNodeType,TransduceNodeType,UnshiftNodeType,]
Const CombineLatestNodeType
Combine
LatestNodeType: StatelessNodeType<"combineLatest", CombineLatestNodeProperties> = createNodeType<'combineLatest', CombineLatestNodeProperties>('combineLatest', {shape: {operations: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {cacheable: false,getDependencies({ operations }: CombineLatestNodeProperties): Array<NodeDependency> {return operations.map((operation) => ({ target: operation }));},run(node: CombineLatestNode, options: never, dependencies: Array<GraphNode>): NodeDefinition {return array(dependencies.map((node) => node.definition));},},},})
Const CombinedMiddlewareNodeType
Const CombinedReducerNodeType
Combined
ReducerNodeType: StatelessNodeType<"combinedReducer", CombinedReducerNodeProperties> = createOperationComposer<'combinedReducer',TransformOperation['type']['name'],TransformOperation>('combinedReducer', ['init', 'step', 'result'])
Const ContainsNodeType
Contains
NodeType: StatelessNodeType<"contains", ContainsNodeProperties> = createNodeType<'contains', ContainsNodeProperties>('contains', {shape: {item: graphTypes.nodeDefinition,target: graphTypes.nodeDefinition,comparator: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: ContainsNodeProperties): Array<NodeDependency> {return [{target,until: {predicate: supportsContainsOperation,errorMessage(node: GraphNode) {return getInvalidTypeErrorMessage('Target node does not support contains operation',{ received: node.definition },);},},},];},run(node: ContainsNode, operation: never, [target]: [GraphNode]): GraphAction {const { item, comparator } = node.definition.properties;return createGraphAction(target, containsOperation(item, comparator));},},},})
Const ContainsOperationType
Contains
OperationType: OperationType<"contains", ContainsProperties> = createOperationType<'contains', ContainsProperties>('contains', {shape: {item: graphTypes.nodeDefinition,comparator: graphTypes.nodeDefinition,},})
Const ContextNodeType
Context
NodeType: StatelessNodeType<"context", ContextNodeProperties> = createNodeType<'context',ContextNodeProperties>('context', {shape: {name: types.oneOfType<string | symbol>([types.string, types.symbol]),},operations: {evaluate: {getContextDependencies({ name }: ContextNodeProperties): [ContextDependency] {return [{ name, required: true, until: shallow }];},run(node: ContextNode,options: never,dependencies: Array<never>,[contextNode]: [GraphNode],): GraphNode {return contextNode;},},},})
Const CountNodeType
Count
NodeType: StatelessNodeType<"count", CountNodeProperties> = createNodeType('count',{operations: {transformItems: {run(node: CountNode, operation: TransformItemsOperation): NodeDefinition {return nodeList([withScopeFrom(node, value(operation.properties.items.length))]);},},init: {run(node: CountNode): NodeDefinition {const initialState = 0;return value(initialState);},},step: {run(node: CountNode, operation: StepOperation<number>): NodeDefinition {return value(operation.properties.acc + 1);},},result: {run(node: CountNode, operation: ResultOperation<number>): NodeDefinition {const { acc, next } = operation.properties;const finalValue = array([value(acc)]);return next ? value(transduce(finalValue, [next])) : value(finalValue);},},},},)
Const CreateBehaviorNodeType
Create
BehaviorNodeType: StatelessNodeType<"createBehavior", CreateBehaviorNodeProperties> = createNodeType<'createBehavior', CreateBehaviorNodeProperties>('createBehavior', {serialize: false,deserialize: false,shape: {operations: types.objectOf(types.saveHash(types.func)),},operations: {[WILDCARD_OPERATION]: {run(node: CreateBehaviorNode, operation: GraphOperation): NodeDefinition {const operationHandler = node.definition.properties.operations[operation.type.name];if (!operationHandler) {return error(getInvalidTypeError(`This createBehavior node does not implement the '${operation.type.name}' operation.`,{expected: Object.keys(node.definition.properties.operations),received: operation.type.name,},),);}return operationHandler(getParams(node.context), operation.properties);},},},})
Const CreateCallerNodeType
Create
CallerNodeType: StaticNodeType<"createCaller", CreateCallerNodeProperties> = createNodeType<'createCaller', CreateCallerNodeProperties>('createCaller', {shape: {key: types.saveHash(types.any),disposeEmitter: types.optional(types.saveHash(types.func)),matcher: types.saveHash(types.func),},})
Const CreateSetterNodeType
Create
SetterNodeType: StaticNodeType<"createSetter", CreateSetterNodeProperties> = createNodeType<'createSetter', CreateSetterNodeProperties>('createSetter', {shape: {key: types.saveHash(types.any),disposeEmitter: types.optional(types.saveHash(types.func)),matcher: types.saveHash(types.func),},})
Const DEFAULT
DEFAULT: symbol = Symbol('DEFAULT')
Const DEFAULT_NODE_TYPES
DEFAULT_
NODE_TYPES: Array<NodeType> = [...ArithmeticNodeTypes,...BrowserNodeTypes,...CollectionNodeTypes,...GraphNodeTypes,...LogicNodeTypes,...RemoteNodeTypes,...StringNodeTypes,]
Const DebugNodeType
Debug
NodeType: StatelessNodeType<"debug", DebugNodeProperties> = createNodeType<'debug',DebugNodeProperties>('debug', {serialize: false,deserialize: false,shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: DebugNodeProperties): [NodeDependency] {return [{target,allowPending: true,allowErrors: true,acceptNil: true,},];},run(node: DebugNode, options: never, [targetValue]: [GraphNode]): NodeDefinition {const { target } = node.definition.properties;const input = target;const resolved = targetValue.definition;window.console.log({ input, resolved });debugger;return target;},},},})
Const DeferNodeType
Defer
NodeType: StaticNodeType<"defer", DeferNodeProperties> = createNodeType<'defer',DeferNodeProperties>('defer', {deserialize: false,serialize: false,shape: {fallbackGenerator: types.saveHash(types.func),target: graphTypes.nodeDefinition,},})
Const DispatchNodeType
Dispatch
NodeType: StatelessNodeType<"dispatch", DispatchNodeProperties> = createNodeType<'dispatch', DispatchNodeProperties>('dispatch', {shape: {event: graphTypes.event,},operations: {evaluate: {cacheable: false,run(node: DispatchNode): NodeDefinition {const { event } = node.definition.properties;node.scope.events.emit(event);return ok();},},},})
Const DivideNodeType
Divide
NodeType: StatelessNodeType<"divide", DivideNodeProperties> = createNodeType<'divide',DivideNodeProperties>('divide', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: DivideNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: untilNumberValueNode(DivideNodeType, 'operand'),}));},run(node: DivideNode, options: never, operands: Array<ValueNode<number>>): NodeDefinition {assertEnoughOperands(operands);const operandValues = operands.map((operand) => operand.definition.properties.value);return value(operandValues.reduce((total, value) => total / value));},},},})
Const DoneNodeType
Done
NodeType: StaticNodeType<"done", DoneNodeProperties> = createNodeType<'done',DoneNodeProperties>('done', {shape: {value: types.optional(types.oneOfType<NodeDefinition | GraphNode>([graphTypes.nodeDefinition,graphTypes.graphNode,]),),},})
Const EMPTY_CONTEXT_DEPENDENCIES
EMPTY_CONTEXT_DEPENDENCIES: Array<never> = []
Const EMPTY_HASH_SET
EMPTY_HASH_SET: Set<string> = createHashSet()
Const EVENT_RESET_VARIABLE
EVENT_RESET_VARIABLE: "$$event:reset-variable" = "$$event:reset-variable"
Const EndsWithNodeType
Ends
WithNodeType: StatelessNodeType<"ends-with", EndsWithNodeProperties> = createNodeType<'ends-with', EndsWithNodeProperties>('ends-with', {shape: {pattern: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ pattern, subject }: EndsWithNodeProperties): Array<NodeDependency> {return [{target: pattern,until: untilStringValueNode(EndsWithNodeType, 'pattern'),},{target: subject,acceptNil: true,until: untilStringValueNode(EndsWithNodeType, 'subject'),},];},run(node: EndsWithNode,options: never,[pattern, subject]: [ValueNode<string>, ValueNode<string>],): NodeDefinition {if (NilNodeType.is(subject)) return value(false);const patternValue = pattern.definition.properties.value;const subjectValue = subject.definition.properties.value;return value((subjectValue || '').endsWith(patternValue));},},},})
Const EntriesNodeType
Entries
NodeType: StaticNodeType<"entries", EntriesNodeProperties> = createNodeType<'entries',EntriesNodeProperties>('entries', {shape: {children: types.optional(graphTypes.nodeDefinition),},})
Const EqNodeType
Eq
NodeType: StatelessNodeType<"eq", EqNodeProperties> = createNodeType<'eq',EqNodeProperties>('eq', {shape: {left: graphTypes.nodeDefinition,right: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ left, right }: EqNodeProperties): Array<NodeDependency> {return [left, right].map((operand) => ({target: operand,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('Eq node operands must resolve to value() nodes', {expected: ValueNodeType,received: node.definition,});},},}));},run(node: EqNode,options: never,[left, right]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {const leftValue = left.definition.properties.value;const rightValue = right.definition.properties.value;return value(leftValue === rightValue);},},},})
Const ErrorNodeType
Error
NodeType: StaticNodeType<"error", ErrorNodeProperties, SerializedErrorNodeProperties> = createNodeType<'error', ErrorNodeProperties, SerializedErrorNodeProperties>('error', {shape: {error: types.shape({message: types.string,stack: types.ignore,}),code: types.optional(types.string),data: types.optional(types.saveHash(types.any)),path: types.optional(types.saveHash(types.arrayOf(types.any))),remotePath: types.optional(types.saveHash(types.arrayOf(types.any))),},serialize(properties: ErrorNodeProperties): SerializedErrorNodeProperties {const { error, code, data, path, remotePath } = properties;return {error: error instanceof Error ? { message: error.message, stack: error.stack } : error,code,data,path,remotePath,};},deserialize(data: SerializedErrorNodeProperties): ErrorNodeProperties {const safeData = data || {};const error = safeData.error || new Error('Unknown error');return {error,code: safeData.code,data: safeData.data,path: safeData.path,remotePath: safeData.remotePath,};},})
Const EvaluateOperationType
Evaluate
OperationType: OperationType<"evaluate"> = createOperationType<'evaluate'>('evaluate',)
Const ExtendNodeType
Extend
NodeType: StatelessNodeType<"extend", ExtendNodeProperties> = createNodeType<'extend',ExtendNodeProperties>('extend', {shape: {nodes: types.arrayOf(graphTypes.nodeDefinition),},operations: {getChild: {run(node: ExtendNode, operation: GetChildOperation): NodeDefinition {return resolveChildNode(node, node.definition.properties.nodes, operation.properties.key);},},},})
Const ExternalStatefulNodeType
External
StatefulNodeType: StatefulNodeType<"stateful", ExternalStatefulNodeProperties<any>, ExternalStatefulNodeState> = createNodeType<'stateful', ExternalStatefulNodeProperties<any>, ExternalStatefulNodeState>('stateful',{state: {currentValue: types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode]),},shape: {valueStream: types.saveHash(types.any),},getInitialState(): ExternalStatefulNodeState {return {currentValue: pending(),};},serialize: false,deserialize: false,operations: {evaluate: {run(node: ExternalStatefulNode<any>,options: never,dependencies: Array<never>,context: Array<never>,state: ExternalStatefulNodeState,): NodeDefinition | GraphNode {return state.currentValue;},onSubscribe(this: NodeExecutionContext<ExternalStatefulNodeState, ExternalStatefulNodeData>,node: ExternalStatefulNode<any>,): void {const subscription = node.definition.properties.valueStream.subscribe((v) => {this.setState((s) => ({...s,currentValue: isGraphNode(v) ? v : toValue(v),}));});this.setData({subscription,});},onUnsubscribe(this: NodeExecutionContext<ExternalStatefulNodeState, ExternalStatefulNodeData>,): void {const subscription = this.getData().subscription;subscription && subscription.unsubscribe();},},},},)
Const FACTORY
FACTORY: unique symbol = Symbol('HASH_FACTORY')
Const FLUSH
FLUSH: "$$event:flush" = "$$event:flush"
Const FactoryNodeType
Factory
NodeType: StatefulNodeType<"factory", FactoryNodeProperties, FactoryNodeState, FactoryNodeData> = createNodeType<'factory', FactoryNodeProperties, FactoryNodeState, FactoryNodeData>('factory', {state: {instance: graphTypes.nodeDefinition,},serialize: false,deserialize: false,shape: {factory: types.saveHash(types.func),},getInitialState(): FactoryNodeState {return {instance: pending(),};},operations: {evaluate: {run(node: FactoryNode,options: never,dependencies: Array<never>,contextDependencies: Array<never>,state: FactoryNodeState,): NodeDefinition {const { instance } = state;return instance;},onSubscribe(this: NodeExecutionContext<FactoryNodeState, FactoryNodeData>,node: FactoryNode,): void {const { factory } = node.definition.properties;this.setState({instance: factory(),});},onInvalidate(this: NodeExecutionContext<FactoryNodeState, FactoryNodeData>,node: FactoryNode,): void {const { factory } = node.definition.properties;this.setState({instance: factory(),});},onUnsubscribe(this: NodeExecutionContext<FactoryNodeState, FactoryNodeData>,node: FactoryNode,): void {this.setState({instance: pending(),});},},},})
Const FetchItemsNodeType
Fetch
ItemsNodeType: StaticNodeType<"fetch-items", FetchItemsNodeProperties> = createNodeType<'fetch-items', FetchItemsNodeProperties>('fetch-items', {shape: {target: graphTypes.nodeDefinition,},operations: {getItems: {getDependencies({ target }: FetchItemsNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsGetItemOperation,},];},run(node: FetchItemsNode, operation: GetItemsOperation, [target]: [GraphNode]) {if (NilNodeType.is(target)) return target;const { transforms } = operation.properties;return resolve([{ target: traverse(target, getItemsOperation()), until: untilPlaceholderOrItems }],([items]: [GraphNode]) => {if (NilNodeType.is(items)) return items;if (!PlaceholderNodeType.is(items)) {return createGraphAction(items, getItemsOperation(transforms));}return applyTransforms(withScopeFrom(items, nodeList([items])) as NodeListNode,transforms,);},);},},},})
Const FieldsNodeType
Fields
NodeType: StaticNodeType<"fields", FieldsNodeProperties, SerializedFieldsNodeProperties> = createNodeType<'fields', FieldsNodeProperties, SerializedFieldsNodeProperties>('fields', {shape: {fields: types.objectOf(graphTypes.nodeDefinition),},serialize<T>({ fields }: FieldsNodeProperties,serialize: (node: NodeDefinition) => T,): SerializedFieldsNodeProperties<T> {return {fields: mapValues(fields, (field) => serialize(field)),};},deserialize<T>({ fields }: SerializedFieldsNodeProperties<T>,deserialize: (node: T) => NodeDefinition,): FieldsNodeProperties {return {fields: mapValues(fields, (field) => deserialize(field)),};},})
Const FilterNodeType
Filter
NodeType: StatelessNodeType<"filter", FilterNodeProperties> = createNodeType('filter',{shape: {predicate: graphTypes.nodeDefinition,},operations: {transformItems: {getDependencies({ predicate }: FilterNodeProperties,operation: TransformItemsOperation,): Array<NodeDependency> {return operation.properties.items.map((item) => ({target: apply([item], predicate),until: untilIsValueNode,}));},run(node: FilterNode,operation: TransformItemsOperation,filterResults: Array<ValueNode<any>>,): NodeDefinition {const { items } = operation.properties;const filterValues = filterResults.map((result) => result.definition.properties.value);return nodeList((zip<GraphNode | ValueNode<any>>(items, filterValues) as Array<[GraphNode, ValueNode<any>]>).filter(([item, filterValue]) => Boolean(filterValue)).map(([item]) => item),);},},init: {run(node: FilterNode, operation: InitOperation): NodeDefinition | GraphAction {const { next } = operation.properties;if (!next) {return error('Filter reducer cannot be used as a base reducer');}return createGraphAction(next, init());},},step: {getDependencies({ predicate }: FilterNodeProperties,operation: StepOperation<any>,): [NodeDependency] {return [{target: apply([operation.properties.item], predicate),until: untilIsValueNode,},];},run(node: FilterNode,operation: StepOperation<any>,[result]: [ValueNode<any>],): NodeDefinition | GraphAction {const { acc, item, next } = operation.properties;if (!next) {return error('Filter reducer cannot be used as a base reducer');}const { value: resultValue } = result.definition.properties;return resultValue ? createGraphAction(next, step(acc, item)) : value(acc);},},result: {run(node: FilterNode, operation: ResultOperation<any>): NodeDefinition | GraphAction {const { acc, next } = operation.properties;if (!next) {return error('Filter reducer cannot be used as a base reducer');}return createGraphAction(next, result(acc));},},},},)
Const FirstItemNodeType
First
ItemNodeType: StatelessNodeType<"firstItem", FirstItemNodeProperties> = createNodeType('firstItem', {operations: {transformItems: {run(node: FirstItemNode, operation: TransformItemsOperation): NodeDefinition {return nodeList(operation.properties.items.slice(0, 1));},},init: {run(node: FirstItemNode, operation: InitOperation): NodeDefinition | GraphAction {const { next } = operation.properties;return next ? createGraphAction(next, init()) : value(undefined);},},step: {run(node: FirstItemNode, operation: StepOperation<any>): NodeDefinition {const { acc, item, next } = operation.properties;return done(next ? traverse(next, step(acc, item)) : value(item));},},result: {run(node: FirstItemNode, operation: ResultOperation<any>): NodeDefinition | GraphAction {const { acc, next } = operation.properties;return next ? createGraphAction(next, result(acc)) : value(nodeList(acc ? [acc] : []));},},},})
Const FirstNodeType
First
NodeType: StaticNodeType<"first"> = createNodeType<'first'>('first')
Const FloorNodeType
Floor
NodeType: StatelessNodeType<"floor", FloorNodeProperties> = createNodeType<'floor',FloorNodeProperties>('floor', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: FloorNodeProperties): Array<NodeDependency> {return [{ target, until: untilNumberValueNode(FloorNodeType, 'target') }];},run(node: FloorNode, options: never, [target]: [ValueNode<number>]): NodeDefinition {return toValue(Math.floor(target.definition.properties.value));},},},})
Const FlowNodeType
Flow
NodeType: StatelessNodeType<"flow", FlowNodeProperties> = createNodeType<'flow',FlowNodeProperties>('flow', {shape: {functions: types.arrayOf(graphTypes.nodeDefinition),},operations: {call: {run(node: FlowNode, operation: CallOperation) {return composeApplyNodes(node.definition.properties.functions, operation.properties.args);},},},})
Const FnNodeType
Fn
NodeType: StatelessNodeType<"fn", FnNodeProperties> = createNodeType<'fn',FnNodeProperties>('fn', {shape: {argIds: types.arrayOf(types.string),body: graphTypes.nodeDefinition,hasNamedArgs: types.bool,},operations: {call: {run(node: FnNode, operation: CallOperation): NodeDefinition | GraphNode {const { argIds, body, hasNamedArgs } = node.definition.properties;const { args } = operation.properties;if (hasNamedArgs) {// Handle calling function with named argumentsif (args && isCallArgumentArray(args)) {return error('An fn() expected to have been called with named arguments, ' +'but was called with an array of arguments.',);}const receivedArgsNames = args ? Object.keys(args) : [];const isMissingArguments = argIds.some((name) => !receivedArgsNames.includes(name));if (isMissingArguments) {return error(getInvalidTypeError('An fn() was called with unexpected number of arguments.', {expected: argIds,received: receivedArgsNames,}),);}const sanitizedArgs = fromPairs(toPairs(args).map(([name, value]) => [`$$named-arg:${name}`,isGraphNode(value) ? value : withScopeFrom(node, value),]),);const childContext = createContext(node.context, sanitizedArgs);return createGraphNode(node.scope, childContext, body);}// Handle calling function with an array of argumentsif (args && isCallArgumentMap(args)) {return error('An fn() expected to have been called with an array of arguments, ' +'but was called with named arguments.',);}if ((!args && argIds.length > 0) || (args && args.length < argIds.length)) {return error(getInvalidTypeError('Too few arguments applied to fn.', {expected: argIds.length,received: args ? args.length : 0,}),);}const trimmedArgs = (args ? args.slice(0, argIds.length) : []).map((arg) =>isGraphNode(arg) ? arg : withScopeFrom(node, arg),);const context = fromPairs(zip<string | GraphNode>(argIds, trimmedArgs) as Array<[string, GraphNode]>);const childContext = createContext(node.context, context);return createGraphNode(node.scope, childContext, body);},},},})
Const FormatNodeType
Format
NodeType: StatelessNodeType<"format", FormatNodeProperties> = createNodeType<'format',FormatNodeProperties>('format', {shape: {format: types.string,data: types.arrayOf(types.arrayOf(types.oneOfType<string | NodeDefinition>([types.string, graphTypes.nodeDefinition]),),),},operations: {evaluate: {getDependencies({ data }: FormatNodeProperties): Array<NodeDependency> {return data.map(([key, dependency]) => ({target: dependency,until: untilStringValueNode(FormatNodeType, `data.${key}`),}));},run(node: FormatNode,options: never,dependencies: Array<ValueNode<string>>,): NodeDefinition {const data = buildFormatInput(node.definition.properties.data, dependencies);return value(es6TemplateStrings(node.definition.properties.format, data));},},},})
Const FromBase64NodeType
From
Base64NodeType: StatelessNodeType<"from-base64", FromBase64NodeProperties> = createNodeType<'from-base64', FromBase64NodeProperties>('from-base64', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: FromBase64NodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(FromBase64NodeType, 'subject'),},];},run(node: FromBase64Node, options: never, [subject]: [ValueNode<string>]): NodeDefinition {if (NilNodeType.is(subject)) return nil();return value(atob(subject.definition.properties.value));},},},})
Const FromPromiseNodeType
From
PromiseNodeType: StatefulNodeType<"fromPromise", FromPromiseNodeProperties, FromPromiseNodeState> = createNodeType<'fromPromise', FromPromiseNodeProperties, FromPromiseNodeState>('fromPromise', {serialize: false,deserialize: false,state: {currentValue: types.optional(graphTypes.nodeDefinition),pendingUpdate: types.optional(types.saveHash(types.any)),updateError: types.optional(graphTypes.nodeDefinition),},shape: {clear: types.optional(types.saveHash(types.func)),get: types.optional(types.saveHash(types.func)),set: types.optional(types.saveHash(types.func)),},getInitialState(): FromPromiseNodeState {return {currentValue: undefined,pendingUpdate: undefined,updateError: undefined,};},operations: {clear: {run(node: FromPromiseNode,options: never,dependencies: never,context: never,state: FromPromiseNodeState,): NodeDefinition {if (!node.definition.properties.clear) {return error('Specified fromPromise node does not support `clear` operation');}return state.pendingUpdate ? pending() : state.updateError || ok();},onSubscribe(this: NodeExecutionContext<FromPromiseNodeState, FromPromiseNodeData>,node: FromPromiseNode,): void {const { clear } = node.definition.properties;if (!clear) return;const pendingUpdate = Promise.resolve(clear(getParams(node.context))).catch((e) => error(e)).then((result) => {if (this.getState().pendingUpdate === pendingUpdate) {this.setState((state) => ({...state,currentValue: isOkNodeDefinition(result) ? undefined : state.currentValue,pendingUpdate: undefined,updateError: isErrorNodeDefinition(result) ? result : undefined,}));if (isOkNodeDefinition(result) && this.getData().isSubscribed) {fetchValue(this, node);}}return result;});this.setState((state) => ({...state,pendingUpdate,pendingError: undefined,}));},},evaluate: {run(node: FromPromiseNode,options: never,dependencies: Array<never>,context: Array<never>,state: FromPromiseNodeState,): NodeDefinition {const { get } = node.definition.properties;if (!get) {return error('Specified fromPromise node is write-only');}const { currentValue } = state;return currentValue || pending();},onInvalidate(this: NodeExecutionContext<FromPromiseNodeState, FromPromiseNodeData>,node: FromPromiseNode,): void {this.setState((state) => ({...state,currentValue: undefined,pendingUpdate: undefined,updateError: undefined,}));fetchValue(this, node);},onSubscribe(this: NodeExecutionContext<FromPromiseNodeState, FromPromiseNodeData>,node: FromPromiseNode,): void {this.setData((data) => ({...data,isSubscribed: true,}));fetchValue(this, node);},onUnsubscribe(this: NodeExecutionContext<FromPromiseNodeState, FromPromiseNodeData>): void {this.setData((data) => ({...data,isSubscribed: false,}));},},set: {run(node: FromPromiseNode,options: never,dependencies: Array<never>,context: Array<never>,state: FromPromiseNodeState,): NodeDefinition {const { set } = node.definition.properties;if (!set) {return error('Specified fromPromise node is read-only');}return state.pendingUpdate ? pending() : state.updateError || ok();},onSubscribe(this: NodeExecutionContext<FromPromiseNodeState, FromPromiseNodeData>,node: FromPromiseNode,operation: SetOperation,): void {const { set } = node.definition.properties;if (!set) return;const { value: newValue } = operation.properties;const { currentValue: previousValue } = this.getState();if (!previousValue) {this.retain();}this.setData((data) => ({...data,pendingGet: undefined,}));const pendingUpdate = Promise.resolve(set(getParams(node.context), valueOf(newValue))).catch((e) => error(e)).then((result) => {if (this.getState().pendingUpdate !== pendingUpdate) return result;this.setState((state) => ({...state,currentValue: isOkNodeDefinition(result) ? newValue : state.currentValue,pendingUpdate: undefined,updateError: isErrorNodeDefinition(result) ? result : undefined,}));return result;});this.setState((state) => ({...state,pendingUpdate,updateError: undefined,}));},},reset: {run(): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<FromPromiseNodeState, FromPromiseNodeData>,node: FromPromiseNode,) {const { currentValue: previousValue } = this.getState();if (previousValue) {this.release();}this.setState((state) => ({...state,currentValue: undefined,pendingUpdate: undefined,}));if (this.getData().isSubscribed) {fetchValue(this, node);}},},},})
Const FromStreamMiddlewareNodeType
From
StreamMiddlewareNodeType: StatelessNodeType<"from-stream-middleware", FromStreamMiddlewareNodeProperties> = createNodeType<'from-stream-middleware', FromStreamMiddlewareNodeProperties>('from-stream-middleware',{shape: {streamFactory: types.saveHash(types.func),},operations: {request: {run(node: FromStreamMiddlewareNode, operation: RequestOperation): NodeDefinition {const responseStream = node.definition.properties.streamFactory(operation.properties.query,);return fromStream(responseStream);},},},},)
Const FromStreamNodeType
From
StreamNodeType: StatefulNodeType<"fromStream", FromStreamNodeProperties, FromStreamNodeState> = createNodeType<'fromStream', FromStreamNodeProperties, FromStreamNodeState>('fromStream', {serialize: false,deserialize: false,state: {currentValue: types.optional(graphTypes.nodeDefinition),},shape: {factory: types.saveHash(types.oneOfType<Function | { subscribe: Function }>([types.func,types.instance({ subscribe: types.func }),types.shape({ subscribe: types.func }),]),),},getInitialState(): FromStreamNodeState {return {currentValue: undefined,};},operations: {evaluate: {run(node: FromStreamNode,options: never,dependencies: Array<never>,context: Array<never>,state: FromStreamNodeState,): NodeDefinition {const { currentValue } = state;return currentValue || pending();},onSubscribe(this: NodeExecutionContext<FromStreamNodeState, FromStreamNodeData>,node: FromStreamNode,): void {const { factory } = node.definition.properties;const { subscription: existingSubscription } = this.getData();let isSync = true;let syncValue: NodeDefinition | undefined;const stream = typeof factory === 'function' ? factory(getParams(node.context)) : factory;const subscription = stream.subscribe((rawValue) => {const valueNode = isNodeDefinition(rawValue) ? rawValue : value(rawValue);if (isSync) {syncValue = valueNode;} else {this.setState({currentValue: valueNode,});}});isSync = false;if (existingSubscription) {existingSubscription.unsubscribe();}this.setData({subscription,});if (syncValue) {this.setState({currentValue: syncValue,});}},onUnsubscribe(this: NodeExecutionContext<FromStreamNodeState, FromStreamNodeData>): void {const { subscription } = this.getData();subscription && subscription.unsubscribe();},},},})
Const FuzzyTraverseNodeType
Fuzzy
TraverseNodeType: StatelessNodeType<"fuzzyTraverse", FuzzyTraverseNodeProperties> = createNodeType<'fuzzyTraverse', FuzzyTraverseNodeProperties>('fuzzyTraverse', {serialize: false,deserialize: false,shape: {operation: graphTypes.graphOperation,target: types.oneOfType([graphTypes.graphNode, graphTypes.nodeDefinition]),},operations: {evaluate: {getDependencies({ operation, target }: FuzzyTraverseNodeProperties): Array<NodeDependency> {return [{target,until: {predicate(node: GraphNode) {return supportsOperationType(operation.type.name, node.definition);},errorMessage(node: GraphNode) {return getInvalidTypeErrorMessage(`Node does not support ${operation.type.name} operation`,{expected: `Node supporting ${operation.type.name} operation`,received: node.definition,},);},},},];},run(node: FuzzyTraverseNode,operation: never,[target]: Array<never>,): GraphAction | GraphNode {if (NilNodeType.is(target) && isGetChildOperation(operation)) return target;return createGraphAction(target, node.definition.properties.operation);},},},})
Const GRAPH_ACTION
GRAPH_ACTION: unique symbol = Symbol.for('muster::GRAPH_ACTION')
Const GRAPH_NODE
GRAPH_NODE: unique symbol = Symbol.for('muster::GRAPH_NODE')
Const GRAPH_OPERATION
GRAPH_OPERATION: unique symbol = Symbol.for('muster::GRAPH_OPERATION')
Const GetChildOperationType
Get
ChildOperationType: OperationType<"getChild", GetChildProperties> = createOperationType<'getChild', GetChildProperties>('getChild', {shape: {key: types.optional(types.saveHash(types.any)),},})
Const GetItemsOperationType
Get
ItemsOperationType: OperationType<"getItems", GetItemsProperties> = createOperationType<'getItems', GetItemsProperties>('getItems', {shape: {transforms: types.arrayOf(types.oneOfType<NodeDefinition | GraphNode>([graphTypes.nodeDefinition,graphTypes.graphNode,]),),},})
Const GetLengthNodeType
Get
LengthNodeType: StatelessNodeType<"get-length", GetLengthNodeProperties> = createNodeType<'get-length', GetLengthNodeProperties>('get-length', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: GetLengthNodeProperties) {return [{target,until: {predicate: supportsLengthOperation,errorMessage(node: GraphNode) {return getInvalidTypeErrorMessage('Target node does not support length operation', {received: node.definition,});},},},];},run(node: GetLengthNode, operation: never, [target]: [GraphNode]): GraphAction {return createGraphAction(target, lengthOperation());},},},})
Const GetNodeType
Get
NodeType: StatelessNodeType<"get", GetNodeProperties> = createNodeType<'get',GetNodeProperties>('get', {shape: {subject: graphTypes.nodeDefinition,key: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject, key }: GetNodeProperties): Array<NodeDependency> {return [{target: subject,until: untilNodeSupportedByGet,},{target: key,until: untilIsValueNodeOrKeyNode,},];},run(node: GetNode,operation: never,[subjectNode, keyNode]: [GraphNode, ValueNode<any> | ListKeyNode],): NodeDefinition | GraphNode | GraphAction {if (isListKeyNode(keyNode)) {if (FirstNodeType.is(keyNode)) {return withScopeFrom(subjectNode,head(applyTransforms(subjectNode.definition, [firstItem()])),);}if (LastNodeType.is(keyNode)) {return withScopeFrom(subjectNode,head(applyTransforms(subjectNode.definition, [lastItem()])),);}if (NthNodeType.is(keyNode)) {const { index } = keyNode.definition.properties;return withScopeFrom(subjectNode,head(applyTransforms(subjectNode.definition, [nthItem(index)])),);}if (LengthNodeType.is(keyNode)) {if (supportsLengthOperation(subjectNode)) {return withScopeFrom(subjectNode, length(subjectNode.definition));}return withScopeFrom(subjectNode,head(applyTransforms(subjectNode.definition, [count()])),);}}if (!supportsGetChildOperation(subjectNode)) {return withScopeFrom(subjectNode,error(untilNodeSupportedByGet.errorMessage(subjectNode)),);}return createGraphAction(subjectNode,getChildOperation(keyNode.definition.properties.value),);},},},})
Const GraphNodeNodeType
Graph
NodeNodeType: StatelessNodeType<"graphNode", GraphNodeNodeProperties> = createNodeType<'graphNode', GraphNodeNodeProperties>('graphNode', {deserialize: false,serialize: false,shape: {value: graphTypes.graphNode,},operations: {evaluate: {run(node: GraphNodeNode): GraphNode {return node.definition.properties.value;},},},})
Const GraphNodeTypes
Graph
NodeTypes: Array<NodeType> = [ActionNodeType,ApplyNodeType,CallNodeType,CatchErrorNodeType,CombineLatestNodeType,ContextNodeType,CreateCallerNodeType,CreateSetterNodeType,CreateBehaviorNodeType,DebugNodeType,DeferNodeType,DispatchNodeType,DoneNodeType,EntriesNodeType,ErrorNodeType,ExtendNodeType,FactoryNodeType,FieldsNodeType,ExternalStatefulNodeType,FlowNodeType,FnNodeType,FromPromiseNodeType,FromStreamNodeType,GetNodeType,GraphNodeNodeType,IfErrorNodeType,IfPendingNodeType,InvalidateNodeType,InvalidateOnNodeType,IsNilNodeType,IsPendingNodeType,IsUpdatingNodeType,IteratorResultNodeType,KeyNodeType,LegacyQueryNodeType,LogNodeType,NilNodeType,OkNodeType,OnNodeType,OnceNodeType,OptimisticNodeType,ParallelNodeType,ParamNodeType,ParentNodeType,InjectDependenciesNodeType,PartialNodeType,PendingNodeType,PlaceholderNodeType,PropertyNodeType,QueryNodeType,QuerySetNodeType,QuerySetCallOperationNodeType,QuerySetGetChildOperationNodeType,QuerySetGetItemsOperationNodeType,QuerySetOperationNodeType,QuerySetResultNodeType,QuerySetSetOperationNodeType,ResetNodeType,ResolveNodeType,RootNodeType,ScopeNodeType,SeriesNodeType,SetNodeType,SetResultNodeType,TakeLastNodeType,TraverseNodeType,TreeNodeType,UpdateNodeType,ValueNodeType,VariableNodeType,WithContextNodeType,WithScopeNodeType,WithTransformsNodeType,]
Const GroupByNodeType
Group
ByNodeType: StatelessNodeType<"group-by", GroupByNodeProperties> = createNodeType('group-by',{shape: {predicate: graphTypes.nodeDefinition,},operations: {transformItems: {getDependencies({ predicate }: GroupByNodeProperties,operation: TransformItemsOperation,): Array<NodeDependency> {return operation.properties.items.map((item) => ({target: apply([item], predicate),until: untilIsValueNode,}));},run(node: GroupByNode,operation: TransformItemsOperation,groupByResults: Array<ValueNode<any>>,): NodeDefinition {const { items } = operation.properties;const groupedItems: Map<any, Array<GraphNode>> = new Map();items.forEach((item, index) => {const key = groupByResults[index].definition.properties.value;const items = groupedItems.get(key);if (items) items.push(item);else groupedItems.set(key, [item]);});return nodeList([...groupedItems.entries()].map(([key, items]) => withScopeFrom(node, nodeList(items))),);},},init: {run(node: GroupByNode): NodeDefinition {const initialState = [] as Array<GraphNode>;return value(initialState);},},step: {run(node: GroupByNode, operation: StepOperation<Array<GraphNode>>): NodeDefinition {const { acc, item } = operation.properties;return value([...acc, item]);},},result: {getDependencies({ predicate }: GroupByNodeProperties): Array<NodeDependency> {return [{target: predicate,until: untilSupportsCallOperation,},];},run(node: GroupByNode,operation: ResultOperation<Array<GraphNode>>,[predicate]: [GraphNode],): NodeDefinition | GraphAction {const { acc, next } = operation.properties;if (!next) {return error('group-by reducer cannot be used as a base reducer');}const sortedItems = resolve(acc.map((item) => ({target: apply([item], predicate.definition),until: untilIsValueNode,})),(groupByResults: Array<ValueNode<any>>) => {const groupedItems: Map<any, Array<GraphNode>> = new Map();acc.forEach((item, index) => {const key = groupByResults[index].definition.properties.value;const items = groupedItems.get(key);if (items) items.push(item);else groupedItems.set(key, [item]);});return nodeList([...groupedItems.entries()].map(([key, items]) =>withScopeFrom(node, nodeList(items)),),);},);return value(transduce(sortedItems, [next]));},},},},)
Const GtNodeType
Gt
NodeType: StatelessNodeType<"gt", GtNodeProperties> = createNodeType<'gt',GtNodeProperties>('gt', {shape: {left: graphTypes.nodeDefinition,right: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ left, right }: GtNodeProperties): Array<NodeDependency> {return [left, right].map((operand) => ({target: operand,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('Gt node operands must resolve to value() nodes', {expected: ValueNodeType,received: node.definition,});},},}));},run(node: GtNode,options: never,[left, right]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {const leftValue = left.definition.properties.value;const rightValue = right.definition.properties.value;return value(leftValue > rightValue);},},},})
Const GteNodeType
Gte
NodeType: StatelessNodeType<"gte", GteNodeProperties> = createNodeType<'gte',GteNodeProperties>('gte', {shape: {left: graphTypes.nodeDefinition,right: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ left, right }: GteNodeProperties): Array<NodeDependency> {return [left, right].map((operand) => ({target: operand,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('Gte node operands must resolve to value() nodes', {expected: ValueNodeType,received: node.definition,});},},}));},run(node: GteNode,options: never,[left, right]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {const leftValue = left.definition.properties.value;const rightValue = right.definition.properties.value;return value(leftValue >= rightValue);},},},})
Const HeadNodeType
Head
NodeType: StatelessNodeType<"head", HeadNodeProperties> = createNodeType<'head',HeadNodeProperties>('head', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: HeadNodeProperties): Array<NodeDependency> {return [{target,until: untilValidTargetNode,},];},run(node: HeadNode,options: never,[targetNode]: [NodeListNode | IterableGraphNode | PlaceholderNode | ItemPlaceholderNode],): GraphNode | NodeDefinition {if (NilNodeType.is(targetNode) ||ItemPlaceholderNodeType.is(targetNode) ||PlaceholderNodeType.is(targetNode)) {return targetNode;}if (NodeListNodeType.is(targetNode)) {const { items } = targetNode.definition.properties;return items.length > 0 ? items[0] : nil();}if (supportsIterateOperation(node)) {return getNextIteratorResult(targetNode, resolveIteratorResult);}// the item must support get items operation thenreturn withScopeFrom(targetNode,resolve([{target: traverse(targetNode, getItemsOperation()),until: untilValidGetItemsResult,},],([itemsNode]: [NodeListNode]) => {if (NilNodeType.is(itemsNode) ||ItemPlaceholderNodeType.is(itemsNode) ||PlaceholderNodeType.is(itemsNode)) {return itemsNode;}const { items } = itemsNode.definition.properties;return items.length > 0 ? items[0] : nil();},),);},},},})
Const INSTANCE
INSTANCE
: StaticNodeDefinition<string, object, object, StatelessNodeType<"count", CountNodeProperties, CountNodeProperties, string, GraphOperation<string, object, object, OperationType<string, object, object>>>> = createNodeDefinition(CountNodeType, {})
Const INSTANCE
INSTANCE
: StaticNodeDefinition<string, object, object, StatelessNodeType<"firstItem", FirstItemNodeProperties, FirstItemNodeProperties, string, GraphOperation<string, object, object, OperationType<string, object, object>>>> = createNodeDefinition(FirstItemNodeType, {})
Const INSTANCE
INSTANCE
: StaticNodeDefinition<string, object, object, StatelessNodeType<"root", object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>>> = createNodeDefinition(RootNodeType, {})
Const INSTANCE
INSTANCE
: StaticNodeDefinition<string, object, object, StatelessNodeType<"arrayReducer", ArrayReducerNodeProperties, ArrayReducerNodeProperties, string, GraphOperation<string, object, object, OperationType<string, object, object>>>> = createNodeDefinition(ArrayReducerNodeType, {})
Const INSTANCE
INSTANCE
: StaticNodeDefinition<string, object, object, StatelessNodeType<"nil", object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>>> = createNodeDefinition(NilNodeType, {})
Const INSTANCE
INSTANCE
: StaticNodeDefinition<string, object, object, StatelessNodeType<"parent", object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>>> = createNodeDefinition(ParentNodeType, {})
Const INSTANCE
INSTANCE
: StaticNodeDefinition<string, object, object, StatelessNodeType<"identity", IdentityNodeProperties, IdentityNodeProperties, string, GraphOperation<string, object, object, OperationType<string, object, object>>>> = createNodeDefinition(IdentityNodeType, {})
Const INSTANCE
INSTANCE
: StaticNodeDefinition<string, object, object, StatelessNodeType<"lastItem", LastItemNodeProperties, LastItemNodeProperties, string, GraphOperation<string, object, object, OperationType<string, object, object>>>> = createNodeDefinition(LastItemNodeType, {})
Const ITEM_ID_CONTEXT
ITEM_ID_CONTEXT: "$$array:item-id" = "$$array:item-id"
Const ITEM_ID_KEY
ITEM_ID_KEY: "$$item-with-id:id" = "$$item-with-id:id"
Const IdentityNodeType
Identity
NodeType: StatelessNodeType<"identity", IdentityNodeProperties> = createNodeType<'identity', IdentityNodeProperties>('identity', {shape: {},operations: {call: {run(node: IdentityNode, operation: CallOperation): GraphNode | NodeDefinition {const { args } = operation.properties;if (!args) return nil();if (isCallArgumentArray(args)) return args[0];const argsNames = Object.keys(args);return args[argsNames[0]];},},},})
Const IdentityOperationType
Identity
OperationType: OperationType<"identity"> = createOperationType<'identity'>('identity',)
Const IfElseNodeType
If
ElseNodeType: StatelessNodeType<"ifElse", IfElseNodeProperties> = createNodeType<'ifElse',IfElseNodeProperties>('ifElse', {shape: {if: graphTypes.nodeDefinition,then: graphTypes.nodeDefinition,else: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ if: ifNode }: IfElseNodeProperties): Array<NodeDependency> {return [{target: ifNode,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('IfElse node condition must resolve to value() nodes',{expected: ValueNodeType,received: node.definition,},);},},},];},run(node: IfElseNode, options: never, [condition]: [ValueNode<any>]): NodeDefinition {const { then: thenNode, else: elseNode } = node.definition.properties;const conditionValue = condition.definition.properties.value;return conditionValue ? thenNode : elseNode;},},},})
Const IfErrorNodeType
If
ErrorNodeType: StatefulNodeType<"ifError", IfErrorNodeProperties, IfErrorNodeState, IfErrorNodeData> = createNodeType<'ifError', IfErrorNodeProperties, IfErrorNodeState, IfErrorNodeData>('ifError', {state: {previousValues: types.shape({evaluate: types.optional(graphTypes.graphNode),}),},shape: {target: graphTypes.nodeDefinition,fallback: types.saveHash(types.func),},getInitialState(): IfErrorNodeState {return {previousValues: {evaluate: undefined,},};},operations: {evaluate: {getDependencies({ target }: IfErrorNodeProperties): Array<NodeDependency> {return [{target,allowErrors: true,},];},run(node: IfErrorNode,options: never,[target]: [GraphNode],context: Array<never>,state: IfErrorNodeState,): NodeDefinition | GraphNode {const { fallback } = node.definition.properties;const { previousValues } = state;if (ErrorNodeType.is(target)) {const previousValue = previousValues.evaluate;return fallback(target.definition, previousValue && previousValue.definition);}return target;},onUpdate(this: NodeExecutionContext<IfErrorNodeState, IfErrorNodeData>,node: IfErrorNode,options: never,[target]: [GraphNode],): void {if (!ErrorNodeType.is(target)) {this.setState((prevState) => ({previousValues: {...prevState.previousValues,evaluate: target,},}));}},},call: {run(node: IfErrorNode, operation: CallOperation): NodeDefinition | GraphNode {const { fallback, target } = node.definition.properties;return resolve([{ target: traverse(target, operation), allowErrors: true }], ([result]) => {if (ErrorNodeType.is(result)) {return withScopeFrom(node, fallback(result.definition, undefined));}return result;});},},},})
Const IfPendingNodeType
If
PendingNodeType: StatelessNodeType<"ifPending", IfPendingNodeProperties> = createNodeType<'ifPending', IfPendingNodeProperties>('ifPending', {shape: {target: graphTypes.nodeDefinition,fallback: types.oneOfType([types.saveHash(types.func),graphTypes.nodeDefinition,types.saveHash(types.any),]),},operations: {evaluate: {run(node: IfPendingNode) {const { fallback, target } = node.definition.properties;const fallbackGenerator = parseFallbackGenerator(fallback);const queryBuilder = new QueryBuilder(uniqueId('if-pending_'));let resolveMirrorQuery: NodeDefinition = ok();let lastQuerySnapshot: QueriesSnapshot | undefined = undefined;let lastResolvedResult: QuerySetResultNodeDefinition | undefined = undefined;return takeLast([onGlobalEvent(FLUSH)(() => {if (!queryBuilder.isModified) return resolveMirrorQuery;queryBuilder.resetModifiedState();const queryBuilderSnapshot = getQueryBuilderSnapshot(queryBuilder);if (lastQuerySnapshot && isEqual(lastQuerySnapshot, queryBuilderSnapshot)) {return resolveMirrorQuery;}lastQuerySnapshot = queryBuilderSnapshot;const querySetWithCallback = buildQuerySetFromQueryBuilderSnapshot(queryBuilderSnapshot,queryBuilder,);const querySetChildren = querySetWithCallback.node.properties.children;const querySetWithTarget = querySet(target, querySetChildren);return (resolveMirrorQuery = resolve([{target: withScopeFrom(node, querySetWithTarget),until: untilIsArrayNodeOrPendingNode,acceptNil: true,allowPending: true,},],([result]: [ArrayNode | PendingNode]) => {if (!PendingNodeType.is(result)) {// Looks like the query is fully resolved - call the placeholder callbackslastResolvedResult = querySetResult(querySetChildren, result.definition);querySetWithCallback.callback(result.definition);return ok();}// Generate the fallback response and then resolve it to a simpler valuereturn resolve([{target: fallbackGenerator(lastResolvedResult),acceptNil: true,},],([fallback]: [GraphNode]) => {// Check if the fallback was resolved to a query set node// This should simplify things a bitif (lastResolvedResult &&fallback.definition.id === lastResolvedResult.properties.result.id) {querySetWithCallback.callback((fallback as QuerySetResultNode).definition.properties.result,);return ok();}// Otherwise - run the querySet against the fallback to generate a correct resultreturn resolve([{target: withScopeFrom(fallback,querySet(fallback.definition, querySetChildren),),acceptNil: true,allowErrors: true,allowPending: true,},],([fallbackResult]: [GraphNode]) => {querySetWithCallback.callback(fallbackResult.definition);return ok();},);},);},));}),placeholder(queryBuilder, []),]);},},},})
Const IncludesNodeType
Includes
NodeType: StatelessNodeType<"includes", IncludesNodeProperties> = createNodeType<'includes', IncludesNodeProperties>('includes', {shape: {pattern: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ pattern, subject }: IncludesNodeProperties): Array<NodeDependency> {return [{target: pattern,until: untilStringValueNode(IncludesNodeType, 'pattern'),},{target: subject,acceptNil: true,until: untilStringValueNode(IncludesNodeType, 'subject'),},];},run(node: IncludesNode,options: never,[pattern, subject]: [ValueNode<string>, ValueNode<string>],): NodeDefinition {if (NilNodeType.is(subject)) return value(false);const patternValue = pattern.definition.properties.value;const subjectValue = subject.definition.properties.value;return value((subjectValue || '').includes(patternValue));},},},})
Const InitOperationType
Init
OperationType: OperationType<"init", InitProperties> = createOperationType<'init',InitProperties>('init', {shape: {next: types.optional(graphTypes.graphNode),},})
Const InjectDependenciesNodeType
Inject
DependenciesNodeType: StatelessNodeType<"inject-dependencies", InjectDependenciesNodeProperties<NodeDefinition>> = createNodeType('inject-dependencies', {shape: {context: types.optional(types.objectOf(graphTypes.nodeDefinition)),dependencies: types.arrayOf(types.optional(types.oneOfType<NodeDefinition | GraphNode>([graphTypes.nodeDefinition,graphTypes.graphNode,]),),),target: graphTypes.nodeDefinition,},serialize: false,deserialize: false,operations: {evaluate: {cacheable: true,getDependencies<T extends NodeDefinition>(properties: InjectDependenciesNodeProperties<T>,operation: EvaluateOperation,): Array<Dependency> {const { target } = properties;if (!supportsEvaluateOperation(target)) {return [];}const evaluateOperationHandler = target.type.operations.evaluate;return getDependencies(properties, evaluateOperationHandler, operation);},getContextDependencies<T extends NodeDefinition>(properties: InjectDependenciesNodeProperties<T>,operation: EvaluateOperation,): Array<ContextDependency> {const { target } = properties;if (!supportsEvaluateOperation(target)) {return [];}const evaluateOperationHandler = target.type.operations.evaluate;return getContextDependencies(properties, evaluateOperationHandler, operation);},run<T extends NodeDefinition>(node: InjectDependenciesNode<T>,operation: EvaluateOperation,dependencies: Array<GraphNode>,contextDependencies: Array<GraphNode>,): GraphNode | GraphAction {const { target, context } = node.definition.properties;if (!supportsEvaluateOperation(target)) {return withScopeFrom(node, target);}const nodeType = target.type;const {dependencies: resolvedDependencies,contextDependencies: resolvedContextDependencies,} = getResolvedDependencies(node.definition,nodeType.operations.evaluate,operation,dependencies,contextDependencies,);const targetContext = context? createContext(node.context, mapValues(context, (value) => withScopeFrom(node, value))): node.context;const targetNode = createGraphNode(node.scope, targetContext, target);if (isStatefulNodeType(nodeType)) {return nodeType.operations.evaluate.run(targetNode,evaluateOperation(),resolvedDependencies,resolvedContextDependencies,node.scope.store.getNodeState(targetNode as StatefulGraphNode),);}return nodeType.operations.evaluate.run(targetNode,evaluateOperation(),resolvedDependencies,resolvedContextDependencies,undefined,);},},},})
Const InvalidateNodeType
Invalidate
NodeType: StatefulNodeType<"invalidate", InvalidateNodeProperties> = createNodeType<'invalidate', InvalidateNodeProperties>('invalidate', {state: {},shape: {target: graphTypes.nodeDefinition,},getInitialState(): InvalidateNodeState {return {};},operations: {evaluate: {cacheable: false,run(): GraphNode | NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<InvalidateNodeState, InvalidateNodeData>,node: InvalidateNode,): void {if (!isDynamicNode(node)) {return;}const { target } = node.definition.properties;// Invalidate the target node via the store if it is already subscribedconst wasSubscribed = node.scope.store.invalidate(withScopeFrom(node, target));if (wasSubscribed) {return;}if (!supportsEvaluateOperation(target)) {return;}// The target node is not currently subscribed, so create a temporary subscription to the// target just in order to figure out the next result in the chain, and invalidate thatlet isSync = true;let isCompleted = false;const unsubscribe = node.scope.store.subscribe(withScopeFrom(node,resolve([createGraphAction(withScopeFrom(node, target), evaluateOperation())],([nextTarget]) => withScopeFrom(nextTarget, invalidate(nextTarget.definition)),),),resolveOperation(),() => {isCompleted = true;if (isSync) return;unsubscribe();},);isSync = false;if (isCompleted) {unsubscribe();}},},},})
Const InvalidateOnNodeType
Invalidate
OnNodeType: StatefulNodeType<"invalidate-on", InvalidateOnNodeProperties, InvalidateOnNodeState> = createNodeType<'invalidate-on', InvalidateOnNodeProperties, InvalidateOnNodeState>('invalidate-on',{state: {},shape: {target: graphTypes.nodeDefinition,predicate: types.saveHash(types.func),},getInitialState(): InvalidateOnNodeState {return {};},operations: {evaluate: {run(node: InvalidateOnNode): NodeDefinition {const { target } = node.definition.properties;return target;},onSubscribe(node: InvalidateOnNode) {const { predicate, target } = node.definition.properties;const { subscription: disposeSubscription } = this.getData();disposeSubscription && disposeSubscription();const subscription = node.scope.events.listen((event) => {if (!predicate(event)) return;const targetNode = withScopeFrom(node, target);node.scope.store.invalidate(targetNode);});this.setData({subscription,});},onUnsubscribe() {const { subscription: disposeSubscription } = this.getData();disposeSubscription && disposeSubscription();},},},},)
Const IsNilNodeType
Is
NilNodeType: StatelessNodeType<"is-nil", IsNilNodeProperties> = createNodeType<'is-nil',IsNilNodeProperties>('is-nil', {serialize: false,deserialize: false,shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: IsNilNodeProperties): [NodeDependency] {return [{target,acceptNil: true,},];},run(node: IsNilNode, options: never, [targetValue]: [GraphNode]): NodeDefinition {return value(NilNodeType.is(targetValue));},},},})
Const IsPendingNodeType
Is
PendingNodeType: StaticNodeType<"isPending", IsPendingNodeProperties> = createNodeType<'isPending', IsPendingNodeProperties>('isPending', {shape: {target: graphTypes.nodeDefinition,},})
Const IsPendingOperationType
Is
PendingOperationType: OperationType<"isPending"> = createOperationType<'isPending'>('isPending',)
Const IsUpdatingNodeType
Is
UpdatingNodeType: StatelessNodeType<"isUpdating", IsUpdatingNodeProperties> = createNodeType<'isUpdating', IsUpdatingNodeProperties>('isUpdating', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: IsUpdatingNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsIsUpdatingOperationOrStaticNode,},];},run(node: IsUpdatingNode,operation: never,[target]: [GraphNode],): NodeDefinition | GraphAction {if (!supportsIsUpdatingOperation(target)) {return value(true);}return createGraphAction(target, isUpdatingOperation());},},},})
Const IsUpdatingOperationType
Is
UpdatingOperationType: OperationType<"isUpdating"> = createOperationType<'isUpdating'>('isUpdating')
Const ItemPlaceholderNodeType
Item
PlaceholderNodeType: StatelessNodeType<"item-placeholder", ItemPlaceholderNodeProperties> = createNodeType<'item-placeholder', ItemPlaceholderNodeProperties>('item-placeholder', {shape: {results: types.arrayOf(types.shape({node: graphTypes.nodeDefinition,pathPart: types.shape({id: types.string,operation: graphTypes.graphOperation,}),}),),isEmpty: types.bool,path: types.arrayOf(types.shape({id: types.string,operation: graphTypes.graphOperation,}),),queryBuilder: types.saveHash(types.any),},operations: {[WILDCARD_OPERATION]: {getDependencies({ path, queryBuilder }: ItemPlaceholderNodeProperties,operation: GraphOperation,): Array<NodeDependency> {return [{target: traverse(placeholder(queryBuilder, path), operation),allowPending: true,until: untilValidPlaceholderResult,},];},run(node: ItemPlaceholderNode,operation: GraphOperation,[placeholder]: [PlaceholderNode],): NodeDefinition | GraphNode {const { results } = node.definition.properties;const matchingResult = results.find((result) => result.pathPart.id === operation.id);if (!matchingResult) return placeholder;return isSetOperation(operation) && isOkNodeDefinition(matchingResult.node)? operation.properties.value: matchingResult.node;},},},})
Const ItemWithIdNodeType
Item
WithIdNodeType: StatelessNodeType<"item-with-id", ItemWithIdNodeProperties> = createNodeType<'item-with-id', ItemWithIdNodeProperties>('item-with-id', {shape: {id: types.string,item: graphTypes.nodeDefinition,},operations: {evaluate: {run(node: ItemWithIdNode): GraphNode {const { id, item } = node.definition.properties;return createGraphNode(node.scope,createContext(node.context, {[ITEM_ID_KEY]: withScopeFrom(node, value(id)),}),item,);},},},})
Const IterateNodeType
Iterate
NodeType: StatelessNodeType<"iterate", IterateNodeProperties> = createNodeType<'iterate',IterateNodeProperties>('iterate', {shape: {target: graphTypes.nodeDefinition,transforms: types.arrayOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])),},operations: {evaluate: {getDependencies({ target, transforms }: IterateNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsIterateOperation,},...transforms.map((transformer) => ({target: transformer,until: untilSupportsStepOperation,})),];},run(node: IterateNode,options: never,[targetNode, ...transforms]: Array<GraphNode>,): NodeDefinition | GraphNode {return withScopeFrom(targetNode,transduce(targetNode.definition, [...transforms, arrayReducer()]),);},},},})
Const IterateOperationType
Iterate
OperationType: OperationType<"iterate"> = createOperationType<'iterate'>('iterate',)
Const IteratorResultNodeType
Iterator
ResultNodeType: StaticNodeType<"iteratorResult", IteratorResultNodeProperties> = createNodeType<'iteratorResult', IteratorResultNodeProperties>('iteratorResult', {shape: {value: types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode]),next: types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode]),},})
Const JoinNodeType
Join
NodeType: StatelessNodeType<"join", JoinNodeProperties> = createNodeType<'join',JoinNodeProperties>('join', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),separator: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ operands, separator }: JoinNodeProperties): Array<NodeDependency> {return [{target: separator,until: untilValidSeparator,},...operands.map((operand) => ({target: operand,acceptNil: true,until: untilValidJoinOperand,})),];},run(node: JoinNode,options: never,[separator, ...operands]: [ValueNode<string>, ValueNode<string | Array<string>>],): NodeDefinition {return value(flatMap(operands.filter((operand) => !NilNodeType.is(operand)), (operand) => {const { value } = operand.definition.properties;return typeof value === 'string' ? [value] : value;}).join(separator.definition.properties.value),);},},},})
Const KeyNodeType
Key
NodeType: StaticNodeType<"key", KeyNodeProperties> = createNodeType<'key',KeyNodeProperties>('key', {shape: {key: graphTypes.nodeDefinition,children: types.optional(graphTypes.nodeDefinition),},})
Const KeysNodeTypes
Keys
NodeTypes: Array<NodeType> = [FirstNodeType,GetLengthNodeType,LastNodeType,LengthNodeType,NthNodeType,]
Const LOCATION_CHANGED
LOCATION_CHANGED: "$$event:location-changed" = "$$event:location-changed"
Const LOCATION_PART_CHANGED
LOCATION_PART_CHANGED: "$$event:location-part-changed" = "$$event:location-part-changed"
Const LastItemNodeType
Last
ItemNodeType: StatelessNodeType<"lastItem", LastItemNodeProperties> = createNodeType('lastItem', {operations: {transformItems: {run(node: LastItemNode, operation: TransformItemsOperation): NodeDefinition {return nodeList(operation.properties.items.slice(-1));},},init: {run(node: LastItemNode): NodeDefinition {return value(undefined);},},step: {run(node: LastItemNode, operation: StepOperation<any>): NodeDefinition {return value(operation.properties.item);},},result: {run(node: LastItemNode, operation: ResultOperation<any>): NodeDefinition {const { acc, next } = operation.properties;const finalValue = nodeList(acc ? [acc] : []);return next ? value(transduce(finalValue, [next])) : value(finalValue);},},},})
Const LegacyQueryNodeType
Legacy
QueryNodeType: StatelessNodeType<"legacyQuery", LegacyQueryNodeProperties> = createNodeType<'legacyQuery', LegacyQueryNodeProperties>('legacyQuery', {shape: {keys: graphTypes.nodeDefinition,root: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ keys }: LegacyQueryNodeProperties): [NodeDependency] {return [{target: keys,until: untilIsFieldsNodeOrCollectionFieldsNode,},];},run(node: LegacyQueryNode,operation: never,[keys]: [FieldsNode | EntriesNode | WithTransformsNode],): NodeDefinition | GraphNode {const { root } = node.definition.properties;if (FieldsNodeType.is(keys)) {if (supportsGetChildOperation(root)) {return resolveFields(withScopeFrom(node, root), keys);}return resolve([{target: root,until: untilSupportsGetChildOperation,},],([rootNode]) => resolveFields(rootNode, keys),);}if (isCollectionFieldsNode(keys)) {if (supportsGetItemsOperation(root)) {return resolveList(withScopeFrom(node, root), keys);}return resolve([{target: root,until: untilSupportsGetItemsOperation,},],([rootNode]) => resolveList(rootNode, keys),);}return error(getInvalidTypeError('Invalid query definition.', {expected: [FieldsNodeType, EntriesNodeType, WithTransformsNodeType],received: keys,}),);},},},})
Const LengthNodeType
Length
NodeType: StaticNodeType<"length"> = createNodeType<'length'>('length')
Const LengthOperationType
Length
OperationType: OperationType<"length", LengthProperties> = createOperationType<'length',LengthProperties>('length', {cacheable: false,shape: {},})
Const LocationDataNodeType
Location
DataNodeType: StatefulNodeType<"locationData", LocationDataNodeProperties, LocationDataNodeState> = createNodeType<'locationData', LocationDataNodeProperties, LocationDataNodeState>('locationData',{state: {currentValue: graphTypes.nodeDefinition,},shape: {history: types.shape({id: types.string,}),paramsEncoder: types.optional(types.shape({encode: types.saveHash(types.func),decode: types.saveHash(types.func),}),),update: types.optional(types.bool),},getInitialState(properties: LocationDataNodeProperties): LocationDataNodeState {return {currentValue: computeCurrentValue(properties.history.location, properties.paramsEncoder),};},operations: {evaluate: {run(node: LocationDataNode,options: never,dependencies: Array<never>,context: Array<never>,state: LocationDataNodeState,): NodeDefinition {return state.currentValue;},onSubscribe(this: NodeExecutionContext<LocationDataNodeState, LocationDataNodeData>,node: LocationDataNode,): void {if (this.getData().disposeEventListener) return;const { history, paramsEncoder } = node.definition.properties;this.setData({disposeEventListener: node.scope.events.listen((event) => {if (event.type !== LOCATION_CHANGED) return;this.setState({currentValue: computeCurrentValue(history.location, paramsEncoder),});}),disposeHistoryListener: history.listen((location) => {this.setState({currentValue: computeCurrentValue(location, paramsEncoder),});}),});},onUnsubscribe(this: NodeExecutionContext<LocationDataNodeState, LocationDataNodeData>,): void {const { disposeEventListener, disposeHistoryListener } = this.getData();disposeEventListener && disposeEventListener();disposeHistoryListener && disposeHistoryListener();},},set: {run(): NodeDefinition {return series([dispatch(LOCATION_PART_CHANGED), ok()]);},onSubscribe(this: NodeExecutionContext<LocationDataNodeState, LocationDataNodeData>,node: LocationDataNode,operation: SetOperation,): void {const { history } = node.definition.properties;const paramsValue = operation.properties.value.properties.value;getHistoryUpdater(history, node.definition.properties.update)({...history.location,search: paramsToSearch(paramsValue, node.definition.properties.paramsEncoder),});this.setState({currentValue: value(paramsValue),});},},},},)
Const LocationNodeType
Location
NodeType: StatefulNodeType<"location", LocationNodeProperties, LocationNodeState> = createNodeType<'location', LocationNodeProperties, LocationNodeState>('location', {state: {currentValue: graphTypes.nodeDefinition,history: types.shape({id: types.string,}),},shape: {hash: types.optional(types.string),paramsEncoder: types.optional(types.shape({encode: types.saveHash(types.func),decode: types.saveHash(types.func),}),),update: types.optional(types.bool),},getInitialState(properties: LocationNodeProperties): LocationNodeState {const history = (properties.hash? createHashHistory({ hashType: properties.hash }): createBrowserHistory({ forceRefresh: false })) as HistoryWithId;history.id = uniqueId('history_');return {currentValue: computeCurrentValue(history.location, properties.paramsEncoder),history,};},operations: {evaluate: {run(node: LocationNode,options: never,dependencies: Array<never>,context: Array<never>,state: LocationNodeState,): NodeDefinition {return state.currentValue;},onSubscribe(this: NodeExecutionContext<LocationNodeState, LocationNodeData>,node: LocationNode,): void {if (this.getData().unsubscribeHistory) return;const { history } = this.getState();const { paramsEncoder } = node.definition.properties;this.setData({unsubscribeEvent: node.scope.events.listen((event) => {if (event.type !== LOCATION_PART_CHANGED) return;this.setState((state) => ({...state,currentValue: computeCurrentValue(history.location, paramsEncoder),}));}),unsubscribeHistory: history.listen((location) => {this.setState((state) => ({...state,currentValue: computeCurrentValue(location, paramsEncoder),}));}),});},onUnsubscribe(this: NodeExecutionContext<LocationNodeState, LocationNodeData>): void {const { unsubscribeEvent, unsubscribeHistory } = this.getData();unsubscribeEvent && unsubscribeEvent();unsubscribeHistory && unsubscribeHistory();},},getChild: {run(node: LocationNode,operation: GetChildOperation,dependencies: Array<never>,context: Array<never>,state: LocationNodeState,): NodeDefinition | GraphNode {const { key } = operation.properties;const { history } = state;const childContext = createChildPathContext(node, key);if (key === 'path') {return createGraphNode(node.scope, childContext, locationPath(history));}if (key === 'params') {const { paramsEncoder, update } = node.definition.properties;return createGraphNode(node.scope,childContext,locationData(history, paramsEncoder, update),);}return nil();},},set: {run(node: LocationNode,options: never,dependencies: Array<never>,context: Array<never>,state: LocationNodeState,): NodeDefinition {return series([dispatch(LOCATION_CHANGED), ok()]);},onSubscribe(this: NodeExecutionContext<LocationNodeState, LocationNodeData>,node: LocationNode,operation: SetOperation,): void {const { history } = this.getState();const value = operation.properties.value.properties.value;const { paramsEncoder } = node.definition.properties;getHistoryUpdater(history, node.definition.properties.update)({pathname: value.path,search: paramsToSearch(value.params, paramsEncoder),});this.setState((state) => ({...state,currentValue: computeCurrentValue(history.location, paramsEncoder),}));},},},})
Const LocationPathNodeType
Location
PathNodeType: StatefulNodeType<"locationPath", LocationPathNodeProperties, LocationPathNodeState> = createNodeType<'locationPath', LocationPathNodeProperties, LocationPathNodeState>('locationPath',{state: {currentValue: graphTypes.nodeDefinition,},shape: {history: types.shape({id: types.string,}),update: types.optional(types.bool),},getInitialState(properties: LocationPathNodeProperties): LocationPathNodeState {return {currentValue: value(properties.history.location.pathname),};},operations: {evaluate: {run(node: LocationPathNode,options: never,dependencies: Array<never>,context: Array<never>,state: LocationPathNodeState,): NodeDefinition {return state.currentValue;},onSubscribe(this: NodeExecutionContext<LocationPathNodeState, LocationPathNodeData>,node: LocationPathNode,): void {if (this.getData().disposeEventListener) return;const { history } = node.definition.properties;this.setData({disposeEventListener: node.scope.events.listen((event) => {if (event.type !== LOCATION_CHANGED) return;this.setState({currentValue: value(history.location.pathname),});}),disposeHistoryListener: history.listen((location) => {this.setState((state) => ({...state,currentValue: value(location.pathname),}));}),});},onUnsubscribe(this: NodeExecutionContext<LocationPathNodeState, LocationPathNodeData>,): void {const { disposeEventListener, disposeHistoryListener } = this.getData();disposeEventListener && disposeEventListener();disposeHistoryListener && disposeHistoryListener();},},set: {run(): NodeDefinition {return series([dispatch(LOCATION_PART_CHANGED), ok()]);},onSubscribe(this: NodeExecutionContext<LocationPathNodeState, LocationPathNodeData>,node: LocationPathNode,operation: SetOperation,): void {const { history } = node.definition.properties;const pathValue = operation.properties.value.properties.value;getHistoryUpdater(history, node.definition.properties.update)({...history.location,pathname: pathValue,});this.setState({currentValue: value(pathValue),});},},},},)
Const LogMiddlewareNodeType
Log
MiddlewareNodeType: StatelessNodeType<"log-middleware", LogMiddlewareNodeProperties> = createNodeType<'log-middleware', LogMiddlewareNodeProperties>('log-middleware', {shape: {logRequests: types.bool,logResponses: types.bool,sink: types.saveHash(types.func),},operations: {request: {run(node: LogMiddlewareNode, operation: RequestOperation): NodeDefinition {const { logRequests, logResponses, sink } = node.definition.properties;const { metadata, next, query } = operation.properties;if (!next) {return error('LogMiddleware cannot be used as a base middleware.');}if (logRequests) {sink(`Request [${operation.id}]:`, getType(operation.properties.query));}return resolve([{target: withScopeFrom(next,traverse(next.definition, requestOperation(query, metadata)),),allowErrors: true,},],([response]) => {if (logResponses) {sink(`Response [${operation.id}]:`, getType(response.definition));}return response;},);},},},})
Const LogNodeType
Log
NodeType: StatelessNodeType<"log", LogNodeProperties> = createNodeType<'log',LogNodeProperties>('log', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: LogNodeProperties): [NodeDependency] {return [{target,allowPending: true,allowErrors: true,acceptNil: true,},];},run(node: LogNode, options: never, [targetValue]: [GraphNode]): NodeDefinition {const { target } = node.definition.properties;const input = target;const output = targetValue.definition;window.console.log({ input: getType(input), output: getType(output) });return target;},},},})
Const LogicNodeTypes
Logic
NodeTypes: Array<NodeType> = [AndNodeType,ChooseNodeType,EqNodeType,GtNodeType,GteNodeType,IfElseNodeType,LtNodeType,LteNodeType,NotNodeType,OrNodeType,OtherwiseNodeType,SwitchOnNodeType,WhenNodeType,]
Const LowerCaseNodeType
Lower
CaseNodeType: StatelessNodeType<"lower-case", LowerCaseNodeProperties> = createNodeType<'lower-case', LowerCaseNodeProperties>('lower-case', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: LowerCaseNodeProperties): Array<NodeDependency> {return [{target: subject,until: untilStringValueNode(LowerCaseNodeType, 'subject'),},];},run(node: LowerCaseNode, options: never, [subject]: [ValueNode<string>]): NodeDefinition {return value(subject.definition.properties.value.toLowerCase());},},},})
Const LtNodeType
Lt
NodeType: StatelessNodeType<"lt", LtNodeProperties> = createNodeType<'lt',LtNodeProperties>('lt', {shape: {left: graphTypes.nodeDefinition,right: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ left, right }: LtNodeProperties): Array<NodeDependency> {return [left, right].map((operand) => ({target: operand,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('Lt node operands must resolve to value() nodes', {expected: ValueNodeType,received: node.definition,});},},}));},run(node: LtNode,options: never,[left, right]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {const leftValue = left.definition.properties.value;const rightValue = right.definition.properties.value;return value(leftValue < rightValue);},},},})
Const LteNodeType
Lte
NodeType: StatelessNodeType<"lte", LteNodeProperties> = createNodeType<'lte',LteNodeProperties>('lte', {shape: {left: graphTypes.nodeDefinition,right: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ left, right }: LteNodeProperties): Array<NodeDependency> {return [left, right].map((operand) => ({target: operand,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('Lte node operands must resolve to value() nodes', {expected: ValueNodeType,received: node.definition,});},},}));},run(node: LteNode,options: never,[left, right]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {const leftValue = left.definition.properties.value;const rightValue = right.definition.properties.value;return value(leftValue <= rightValue);},},},})
Const MATCHER
MATCHER: unique symbol = Symbol.for('muster::MATCHER')
Const MATCHERS
MATCHERS: object
Type declaration
-
[id: string]: object
-
-
param: string | undefined
Const MAX_OPERATION_COUNT
MAX_OPERATION_COUNT: 9999999 = 9999999
Const MAX_STACK_SIZE
MAX_STACK_SIZE: 512 = 512
Const MISSING_PARAM_NAME
MISSING_PARAM_NAME: "$$graph-missing" = "$$graph-missing"
Const MapNodeType
Map
NodeType: StatelessNodeType<"map", MapNodeProperties> = createNodeType('map', {shape: {transform: graphTypes.nodeDefinition,},operations: {transformItems: {getDependencies({ transform }: MapNodeProperties,operation: TransformItemsOperation,): Array<NodeDependency> {return operation.properties.items.map((item) => {const transformItem = fuzzyTraverse(transform, callOperation([item]));return resolveShallow(transformItem);});},run(node: MapNode,operation: TransformItemsOperation,items: Array<GraphNode>,): NodeDefinition {return nodeList(items);},},init: {run(node: MapNode, operation: InitOperation): NodeDefinition | GraphAction {const { next } = operation.properties;if (!next) {return error('Map reducer cannot be used as a base reducer');}return createGraphAction(next, init());},},step: {run(node: MapNode, operation: StepOperation<any>): NodeDefinition | GraphAction {const { acc, item, next } = operation.properties;if (!next) {return error('Map reducer cannot be used as a base reducer');}const { transform } = node.definition.properties;const transformedItem = apply([item], transform);return createGraphAction(next, step(acc, withScopeFrom(node, transformedItem)));},},result: {run(node: MapNode, operation: ResultOperation<any>): NodeDefinition | GraphAction {const { acc, next } = operation.properties;if (!next) {return error('Map reducer cannot be used as a base reducer');}return createGraphAction(next, result(acc));},},},})
Const MatchPatternNodeType
Match
PatternNodeType: StatelessNodeType<"match-pattern", MatchPatternNodeProperties> = createNodeType<'match-pattern', MatchPatternNodeProperties>('match-pattern', {shape: {regex: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ regex, subject }: MatchPatternNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(MatchPatternNodeType, 'subject'),},{target: regex,until: untilRegexNode(MatchPatternNodeType, 'regex'),},];},run(node: MatchPatternNode,options: never,[subject, regex]: [ValueNode<string>, RegexNode],): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;const pattern = regex.definition.properties.pattern;const result = subjectValue.match(pattern);return result ? array(result.map(value)) : nil();},},},})
Const MaxNodeType
Max
NodeType: StatelessNodeType<"max", MaxNodeProperties> = createNodeType<'max',MaxNodeProperties>('max', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: MaxNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: untilNumberValueNode(MaxNodeType, 'operand'),}));},run(node: MaxNode, options: never, operands: Array<ValueNode<number>>): NodeDefinition {if (operands.length === 0) {return value(0);}return value(Math.max(...operands.map((operand) => operand.definition.properties.value)));},},},})
Const MinNodeType
Min
NodeType: StatelessNodeType<"min", MinNodeProperties> = createNodeType<'min',MinNodeProperties>('min', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: MinNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: untilNumberValueNode(MinNodeType, 'operand'),}));},run(node: MinNode, options: never, operands: Array<ValueNode<number>>): NodeDefinition {if (operands.length === 0) {return value(0);}return value(Math.min(...operands.map((operand) => operand.definition.properties.value)));},},},})
Const MockResponseMiddlewareNodeType
Mock
ResponseMiddlewareNodeType: StatelessNodeType<"mock-response-middleware", MockResponseMiddlewareNodeProperties> = createNodeType('mock-response-middleware', {shape: {responseFactory: types.saveHash(types.func),},operations: {request: {run(node: MockResponseMiddlewareNode, operation: RequestOperation): NodeDefinition {return node.definition.properties.responseFactory(operation.properties.query);},},},})
Const ModNodeType
Mod
NodeType: StatelessNodeType<"mod", ModNodeProperties> = createNodeType<'mod',ModNodeProperties>('mod', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: ModNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: untilNumberValueNode(ModNodeType, 'operand'),}));},run(node: ModNode, options: never, operands: Array<ValueNode<number>>): NodeDefinition {assertEnoughOperands(operands);const operandValues = operands.map((operand) => operand.definition.properties.value);return value(operandValues.reduce((total, value) => total % value));},},},})
Const MultiplyNodeType
Multiply
NodeType: StatelessNodeType<"multiply", MultiplyNodeProperties> = createNodeType<'multiply', MultiplyNodeProperties>('multiply', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: MultiplyNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: untilNumberValueNode(MultiplyNodeType, 'operand'),}));},run(node: MultiplyNode, options: never, operands: Array<ValueNode<number>>): NodeDefinition {const operandValues = operands.map((operand) => operand.definition.properties.value);return value(operandValues.reduce((total, value) => total * value, 1));},},},})
Const NODE_DEFINITION
NODE_DEFINITION: unique symbol = Symbol.for('muster::NODE_DEFINITION')
Const NODE_MAP_MATCHER
NODE_
MAP_MATCHER: Matcher<object, Matcher<NodeDefinition<any, any, any, object, any, StaticNodeType<any, any, any> | StatelessNodeType<any, any, any, string, GraphOperation<string, object, object, OperationType<string, object, object>>> | StatefulNodeType<any, any, any, object, any, string, GraphOperation<string, object, object, OperationType<string, object, object>>>>, any>> = types.objectOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.proxiedNode]),)
Const NODE_TYPE
NODE_TYPE: unique symbol = Symbol.for('muster::NODE_TYPE')
Const NOT_FOUND
NOT_FOUND: "NOT_FOUND" = "NOT_FOUND"
Const NilNodeType
Nil
NodeType: StatelessNodeType<"nil"> = createNodeType<'nil'>('nil', {operations: {evaluate: {run(): NodeDefinition {return value(undefined);},},[WILDCARD_OPERATION]: {run(node: NilNode): GraphNode {return node;},},},})
Const NodeListNodeType
Node
ListNodeType: StatelessNodeType<"nodeList", NodeListNodeProperties> = createNodeType<'nodeList', NodeListNodeProperties>('nodeList', {shape: {items: types.arrayOf(graphTypes.graphNode),},operations: {getItems: {getDependencies(properties: NodeListNodeProperties,operation: GetItemsOperation,): Array<NodeDependency> {const { transforms } = operation.properties;return transforms.length === 0? []: [{target: transforms[0],until: untilSupportsTransformItemsOperation,},];},run(node: NodeListNode,operation: GetItemsOperation,[firstTransform]: [GraphNode],): NodeDefinition | GraphNode {const { items } = node.definition.properties;const { transforms } = operation.properties;if (transforms.length === 0) {return node;}const remainingTransforms = transforms.slice(1);return resolve([{target: traverse(firstTransform, transformItems(items)),until: untilSupportsGetItemsOperation,},],([transformedItems]: [ListGraphNode]) =>remainingTransforms.length === 0? transformedItems: createGraphAction(transformedItems, getItemsOperation(remainingTransforms)),);},},iterate: {run(node: NodeListNode): NodeDefinition {const { items } = node.definition.properties;if (items.length === 0) {return nil();}return iteratorResult(items[0], nodeList(items.slice(1)));},},length: {run(node: NodeListNode): NodeDefinition {return value(node.definition.properties.items.length);},},},})
Const NotNodeType
Not
NodeType: StatelessNodeType<"not", NotNodeProperties> = createNodeType<'not',NotNodeProperties>('not', {shape: {condition: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ condition }: NotNodeProperties): Array<NodeDependency> {return [{target: condition,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('Not node condition must resolve to a value() node',{expected: ValueNodeType,received: node.definition,},);},},},];},run(node: NotNode, options: never, [condition]: [ValueNode<any>]): NodeDefinition {return value(!condition.definition.properties.value);},},},})
Const NthItemNodeType
Nth
ItemNodeType: StatelessNodeType<"nthItem", NthItemNodeProperties> = createNodeType('nthItem',{shape: {index: graphTypes.nodeDefinition,},operations: {transformItems: {getDependencies({ index }: NthItemNodeProperties): Array<NodeDependency> {return [{target: index,until: untilIsPositiveIntegerValueNode,},];},run(node: NthItemNode,operation: TransformItemsOperation,[index]: [ValueNode<number>],): NodeDefinition {const { value: indexValue } = index.definition.properties;return nodeList(operation.properties.items.slice(indexValue, indexValue + 1));},},init: {run(node: NthItemNode): NodeDefinition {return value(0);},},step: {getDependencies({ index }: NthItemNodeProperties): Array<NodeDependency> {return [{target: index,until: untilIsPositiveIntegerValueNode,},];},run(node: NthItemNode,operation: StepOperation<number>,[target]: [ValueNode<number>],): NodeDefinition {const { acc, item } = operation.properties;const { value: targetIndex } = target.definition.properties;const currentIndex = acc;if (currentIndex === targetIndex) {return done(value(item));}return value(currentIndex + 1);},},result: {run(node: NthItemNode, operation: ResultOperation<number | GraphNode>): NodeDefinition {const { acc, next } = operation.properties;const finalValue = nodeList(isGraphNode(acc) ? [acc] : []);return next ? value(transduce(finalValue, [next])) : value(finalValue);},},},},)
Const OPERATION_TYPE
OPERATION_TYPE: unique symbol = Symbol.for('muster::OPERATION_TYPE')
Const OnGlobalEventDebouncedNodeType
On
GlobalEventDebouncedNodeType: StatefulNodeType<"on-global-event-debounced", OnGlobalEventDebouncedNodeProperties, OnGlobalEventDebouncedState, OnGlobalEventDebouncedData> = createNodeType<'on-global-event-debounced',OnGlobalEventDebouncedNodeProperties,OnGlobalEventDebouncedState,OnGlobalEventDebouncedData>('on-global-event-debounced', {shape: {delay: types.number,eventType: types.oneOfType([types.string, types.symbol]),factory: types.saveHash(types.func),},state: {currentValue: graphTypes.nodeDefinition,},getInitialState() {return {currentValue: pending(),};},operations: {evaluate: {run(node: OnGlobalEventDebouncedNode,operation: never,dependencies: never,context: never,state: OnGlobalEventDebouncedState,): NodeDefinition {return state.currentValue;},onSubscribe(this: NodeExecutionContext<OnGlobalEventDebouncedState, OnGlobalEventDebouncedData>,node: OnGlobalEventDebouncedNode,): void {const { delay, eventType, factory } = node.definition.properties;const debouncedCallback = debounce(() => {this.setState((state) => ({...state,currentValue: factory(),}));}, delay);this.setData({disposeGlobalEventListener: node.scope.globalEvents.listen((event) => {if (event.type !== eventType) return;debouncedCallback();}),});},onUnsubscribe(this: NodeExecutionContext<OnGlobalEventDebouncedState, OnGlobalEventDebouncedData>,): void {const { disposeGlobalEventListener } = this.getData();disposeGlobalEventListener && disposeGlobalEventListener();},},},})
Const OnGlobalEventNodeType
On
GlobalEventNodeType: StatefulNodeType<"on-global-event", OnGlobalEventNodeProperties, OnGlobalEventState, OnGlobalEventData> = createNodeType<'on-global-event',OnGlobalEventNodeProperties,OnGlobalEventState,OnGlobalEventData>('on-global-event', {shape: {eventType: types.oneOfType([types.string, types.symbol]),factory: types.saveHash(types.func),},state: {currentValue: graphTypes.nodeDefinition,},getInitialState() {return {currentValue: pending(),};},operations: {evaluate: {run(node: OnGlobalEventNode,operation: never,dependencies: never,context: never,state: OnGlobalEventState,): NodeDefinition {return state.currentValue;},onSubscribe(this: NodeExecutionContext<OnGlobalEventState, OnGlobalEventData>,node: OnGlobalEventNode,): void {const { eventType, factory } = node.definition.properties;this.setData({disposeGlobalEventListener: node.scope.globalEvents.listen((event) => {if (event.type !== eventType) return;this.setState((state) => ({...state,currentValue: factory(),}));}),});},onUnsubscribe(this: NodeExecutionContext<OnGlobalEventState, OnGlobalEventData>): void {const { disposeGlobalEventListener } = this.getData();disposeGlobalEventListener && disposeGlobalEventListener();},},},})
Const OnNodeType
On
NodeType: StatefulNodeType<"on", OnNodeProperties, OnNodeState> = createNodeType<'on',OnNodeProperties,OnNodeState>('on', {state: {currentValue: types.optional(graphTypes.nodeDefinition),},shape: {initialValue: graphTypes.nodeDefinition,callback: types.saveHash(types.func),},getInitialState(): OnNodeState {return {currentValue: undefined,};},operations: {evaluate: {run(node: OnNode,options: never,dependencies: Array<never>,context: Array<never>,state: OnNodeState,): NodeDefinition {const { currentValue } = state;return currentValue || node.definition.properties.initialValue;},onSubscribe(node: OnNode) {const { callback } = node.definition.properties;const { subscription: existingSubscription } = this.getData();if (existingSubscription) {existingSubscription();}const subscription = node.scope.events.listen((event) => {const updatedValue = callback(event, getParams(node.context));if (updatedValue) {this.setState((prevState) => ({...prevState,currentValue: updatedValue,}));}});this.setData({subscription,});},onUnsubscribe(node: OnNode) {const { subscription: existingSubscription } = this.getData();if (existingSubscription) {existingSubscription();}},},reset: {run(node: OnNode,options: never,dependencies: Array<never>,context: Array<never>,state: OnNodeState,): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<OnNodeState, OnNodeData>, node: OnNode): void {const { currentValue: previousValue } = this.getState();if (!previousValue) {return;}this.setState((prevState) => ({...prevState,currentValue: undefined,}));},},},})
Const OnStreamEmissionNodeType
On
StreamEmissionNodeType: StatefulNodeType<"on-stream-emission", OnStreamEmissionNodeProperties, OnStreamEmissionState, OnStreamEmissionData> = createNodeType<'on-stream-emission',OnStreamEmissionNodeProperties,OnStreamEmissionState,OnStreamEmissionData>('on-stream-emission', {shape: {factory: types.saveHash(types.func),stream: types.saveHash(types.any),},state: {currentValue: graphTypes.nodeDefinition,},getInitialState() {return {currentValue: pending(),};},operations: {evaluate: {run(node: OnStreamEmissionNode,operation: never,dependencies: never,context: never,state: OnStreamEmissionState,): NodeDefinition {return state.currentValue;},onSubscribe(this: NodeExecutionContext<OnStreamEmissionState, OnStreamEmissionData>,node: OnStreamEmissionNode,): void {const { factory, stream } = node.definition.properties;this.setData({streamSubscription: stream.subscribe(() => {this.setState((state) => ({...state,currentValue: factory(),}));}),});},onUnsubscribe(this: NodeExecutionContext<OnStreamEmissionState, OnStreamEmissionData>): void {const { streamSubscription } = this.getData();streamSubscription && streamSubscription.unsubscribe();},},},})
Const OnceNodeType
Once
NodeType: StatefulNodeType<"once", OnceNodeProperties, OnceNodeState, OnceNodeData> = createNodeType<'once', OnceNodeProperties, OnceNodeState, OnceNodeData>('once', {state: {currentValue: types.oneOfType<NodeDefinition | GraphNode>([graphTypes.nodeDefinition,graphTypes.graphNode,]),},shape: {target: types.oneOfType<NodeDefinition | GraphNode | NodeDependency>([graphTypes.nodeDefinition,graphTypes.graphNode,graphTypes.nodeDependency,]),},getInitialState(): OnceNodeState {return {currentValue: pending(),};},operations: {evaluate: {cacheable: false,run(node: OnceNode,options: never,dependencies: Array<never>,context: Array<never>,state: OnceNodeState,): NodeDefinition | GraphNode {const { currentValue } = state;return currentValue;},onSubscribe(node: OnceNode): void {const { target } = node.definition.properties;this.setState((prevState) => ({...prevState,currentValue: resolve([isGraphNode(target) || isNodeDefinition(target) ? { target } : target],([result]: [GraphNode]) => {this.setState((state: OnceNodeState): OnceNodeState => ({...state,currentValue: result,}),);return result;},),}));},},},})
Const OptimisticNodeType
Optimistic
NodeType: StatefulNodeType<"optimistic", OptimisticNodeProperties> = createNodeType<'optimistic', OptimisticNodeProperties>('optimistic', {shape: {target: graphTypes.nodeDefinition,},state: {pendingSetOperations: types.arrayOf(types.string),setResults: types.objectOf(graphTypes.graphNode),value: types.optional(graphTypes.graphNode),},getInitialState(): OptimisticNodeState {return {pendingSetOperations: [],setResults: {},value: undefined,};},operations: {evaluate: {run(node: OptimisticNode,operation: never,dependencies: never,context: never,state: OptimisticNodeState,): GraphNode | NodeDefinition {return state.value || node.definition.properties.target;},},isUpdating: {run(node: OptimisticNode,operation: never,dependencies: never,context: never,state: OptimisticNodeState,): NodeDefinition {return value(state.pendingSetOperations.length > 0);},},set: {run(node: OptimisticNode,operation: SetOperation,dependencies: never,context: never,state: OptimisticNodeState,): GraphNode {return state.setResults[operation.id];},onSubscribe(this: NodeExecutionContext<OptimisticNodeState, OptimisticNodeData>,node: OptimisticNode,operation: SetOperation,): void {const { target } = node.definition.properties;const nodeToResolve = withScopeFrom(node, set(target, operation.properties.value));this.setState((state) => ({...state,pendingSetOperations: [...state.pendingSetOperations, operation.id],setResults: {...state.setResults,[operation.id]: withScopeFrom(node, ok()),},value: withScopeFrom(node, operation.properties.value),}));const unsubscribe = node.scope.store.subscribe(nodeToResolve,resolveOperation(),(value) => {if (PendingNodeType.is(value)) return;this.setState((state) => ({...state,pendingSetOperations: state.pendingSetOperations.filter((id) => id !== operation.id),setResults: ErrorNodeType.is(value)? {...state.setResults,[operation.id]: value,}: state.setResults,value: ErrorNodeType.is(value) ? undefined : value,}));},);this.setData((data) => ({...data,setSubscriptions: {...data.setSubscriptions,[operation.id]: unsubscribe,},}));},onUnsubscribe(this: NodeExecutionContext<OptimisticNodeState, OptimisticNodeData>,node: OptimisticNode,operation: SetOperation,): void {const unsubscribe = this.getData().setSubscriptions![operation.id];unsubscribe();this.setData((data) => ({...data,setSubscriptions: omit(data.setSubscriptions, operation.id),}));this.setState((state) => ({...state,pendingSetOperations: state.pendingSetOperations.filter((id) => id !== operation.id),setResults: omit(state.setResults, operation.id),}));},},},})
Const OrNodeType
Or
NodeType: StatelessNodeType<"or", OrNodeProperties> = createNodeType<'or',OrNodeProperties>('or', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: OrNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('Or node operands must resolve to value() nodes', {expected: ValueNodeType,received: node.definition,});},},}));},run(node: OrNode, options: never, operands: Array<ValueNode<any>>): NodeDefinition {return value(operands.some((operand) => Boolean(operand.definition.properties.value)));},},},})
Const OtherwiseNodeType
Otherwise
NodeType: StaticNodeType<"otherwise", OtherwiseNodeProperties> = createNodeType<'otherwise', OtherwiseNodeProperties>('otherwise', {shape: {value: graphTypes.nodeDefinition,},})
Const PARAM_NAME_PREFIX
PARAM_NAME_PREFIX: "$$param:" = "$$param:"
Const PARENT
PARENT: unique symbol = Symbol('PARENT')
Const PARENT_SCOPE_PATH_KEY
PARENT_SCOPE_PATH_KEY: unique symbol = Symbol('PARENT_SCOPE_PATH_KEY')
Const PATH_KEY
PATH_KEY: unique symbol = Symbol('PATH_KEY')
Const PENDING
PENDING: never = {} as never
Const PROXIED_NODE
PROXIED_NODE: unique symbol = Symbol('muster::PROXIED_NODE')
Const PROXIED_NODE_DEFINITION
PROXIED_NODE_DEFINITION: unique symbol = Symbol('muster::PROXIED_NODE_DEFINITION')
Const ParallelNodeType
Parallel
NodeType: StatelessNodeType<"parallel", ParallelNodeProperties> = createNodeType<'parallel', ParallelNodeProperties>('parallel', {shape: {operations: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {cacheable: false,getDependencies({ operations }: ParallelNodeProperties): Array<NodeDependency> {return operations.map((operation) => ({ target: operation, once: true }));},run(node: ParallelNode, options: never, dependencies: Array<GraphNode>): NodeDefinition {return array(dependencies.map((node) => node.definition));},},},})
Const ParamNodeType
Param
NodeType: StatelessNodeType<"param", ParamNodeProperties> = createNodeType<'param',ParamNodeProperties>('param', {shape: {name: types.string,},operations: {evaluate: {getContextDependencies({ name }: ParamNodeProperties): [ContextDependency] {return [{ name: getParamContextId(name), required: true, until: shallow }];},run(node: ParamNode,options: never,dependencies: Array<never>,[paramNode]: [ValueNode<ChildKey>],): GraphNode {return paramNode;},},},})
Const ParentNodeType
Parent
NodeType: StatelessNodeType<"parent"> = createNodeType<'parent'>('parent', {operations: {evaluate: {getContextDependencies(): [ContextDependency] {return [{name: PARENT,required: false,until: shallow,defaultValue: error('Cannot resolve parent of root node'),},];},run(node: ParentNode,options: never,dependencies: Array<never>,[parentNode]: [GraphNode],): GraphNode {return parentNode;},},},})
Const ParseFloatNodeType
Parse
FloatNodeType: StatelessNodeType<"parse-float", ParseFloatNodeProperties> = createNodeType<'parse-float', ParseFloatNodeProperties>('parse-float', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: ParseFloatNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(ParseFloatNodeType, 'subject'),},];},run(node: ParseFloatNode,options: never,[subject]: [ValueNode<string>, ValueNode<number>],): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;return value(Number.parseFloat(subjectValue));},},},})
Const ParseIntNodeType
Parse
IntNodeType: StatelessNodeType<"parse-int", ParseIntNodeProperties> = createNodeType<'parse-int', ParseIntNodeProperties>('parse-int', {shape: {radix: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ radix, subject }: ParseIntNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(ParseIntNodeType, 'subject'),},{target: radix,until: untilPositiveIntegerValueNode(ParseIntNodeType, 'radix'),},];},run(node: ParseIntNode,options: never,[subject, radix]: [ValueNode<string>, ValueNode<number>],): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;const radixValue = radix.definition.properties.value;return value(Number.parseInt(subjectValue, radixValue));},},},})
Const PartialNodeType
Partial
NodeType: StatelessNodeType<"partial", PartialNodeProperties> = createNodeType<'partial',PartialNodeProperties>('partial', {shape: {args: types.oneOfType([types.objectOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])),types.arrayOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])),]),target: graphTypes.nodeDefinition,},operations: {call: {getDependencies({ target }: PartialNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsCallOperation,},];},run(node: PartialNode,operation: CallOperation,[target]: [GraphNode],): NodeDefinition | GraphAction {const { args } = node.definition.properties;const { args: inputArgs } = operation.properties;if (isCallArgumentMap(args)) {// Handle the named arguments mapif (inputArgs && !isCallArgumentMap(inputArgs)) {return error(getInvalidTypeError('A partial node was called with unexpected type of arguments.', {expected: 'Named arguments',received: 'Array of arguments',}),);}const combinedArgs = inputArgs ? { ...inputArgs, ...args } : args;const argsGraphNodes = mapValues(combinedArgs, (arg) =>isGraphNode(arg) ? arg : withScopeFrom(node, arg),);return createGraphAction(target, callOperation(argsGraphNodes));}// Handle the positional argumentsif (inputArgs && !isCallArgumentArray(inputArgs)) {return error(getInvalidTypeError('A partial node was called with unexpected type of arguments.', {expected: 'Array of arguments',received: 'Named arguments',}),);}const combinedArgs = inputArgs ? [...args, ...inputArgs] : args;const argsGraphNodes = combinedArgs.map((arg) =>isGraphNode(arg) ? arg : withScopeFrom(node, arg),);return createGraphAction(target, callOperation(argsGraphNodes));},},},})
Const PendingNodeType
Pending
NodeType: StaticNodeType<"pending"> = createNodeType<'pending'>('pending')
Const PlaceholderNodeType
Placeholder
NodeType: StatefulNodeType<"placeholder", PlaceholderNodeProperties, PlaceholderNodeState, PlaceholderNodeData> = createNodeType<'placeholder',PlaceholderNodeProperties,PlaceholderNodeState,PlaceholderNodeData>('placeholder', {state: {results: types.objectOf(graphTypes.nodeDefinition),statefulNodes: types.objectOf(graphTypes.nodeDefinition),},shape: {path: types.arrayOf(types.shape({id: types.string,operation: graphTypes.graphOperation,}),),queryBuilder: types.saveHash(types.any),},serialize: false,deserialize: false,getInitialState(): PlaceholderNodeState {return {results: {},statefulNodes: {},};},operations: {[WILDCARD_OPERATION]: {run(node: PlaceholderNode,operation: GraphOperation,dependencies: never,context: never,state: PlaceholderNodeState,): NodeDefinition | GraphNode {return state.results[operation.id] || pending();},onSubscribe(this: NodeExecutionContext<PlaceholderNodeState, PlaceholderNodeData>,node: PlaceholderNode,operation: GraphOperation,): void {handleOperation(this, node, operation);},onInvalidate(this: NodeExecutionContext<PlaceholderNodeState, PlaceholderNodeData>,node: PlaceholderNode,operation: GraphOperation,): void {if (isGetChildOperation(operation)) return;handleOperation(this, node, operation);},onUnsubscribe(this: NodeExecutionContext<PlaceholderNodeState, PlaceholderNodeData>,node: PlaceholderNode,operation: GraphOperation,): void {const { disposeRequest } = this.getData();const disposeCurrentRequest = disposeRequest && disposeRequest[operation.id];if (disposeCurrentRequest) {disposeCurrentRequest();this.setData((data) => ({...data,disposeRequest: omit(data.disposeRequest, operation.id),}));}this.setState((state) => ({...state,results: omit(state.results, operation.id),}));},},},})
Const PopNodeType
Pop
NodeType: StatefulNodeType<"pop", PopNodeProperties, PopNodeState, __type> = createNodeType<'pop', PopNodeProperties, PopNodeState, {}>('pop', {shape: {id: types.number,target: graphTypes.nodeDefinition,},state: {currentValue: types.optional(graphTypes.nodeDefinition),},getInitialState() {return {currentValue: undefined,};},operations: {evaluate: {cacheable: false,run(node: PopNode,options: never,dependencies: never,context: never,state: PopNodeState,): GraphNode {return state.currentValue!;},onSubscribe(this: NodeExecutionContext<PopNodeState, {}>, node: PopNode): void {if (this.getState().currentValue) return;const { target } = node.definition.properties;this.setState(() => ({currentValue: withScopeFrom(node,resolve([{ target, until: untilSupportsPopOperation }], ([resolvedTarget]) => {return withScopeFrom(resolvedTarget,resolve([createGraphAction(resolvedTarget, popOperation())], ([result]) => {this.setState(() => ({ currentValue: result }));return result;}),);}),),}));},},},})
Const PopOperationType
Pop
OperationType: OperationType<"pop", PopProperties> = createOperationType<'pop',PopProperties>('pop', {cacheable: false,shape: {},})
Const PowNodeType
Pow
NodeType: StatelessNodeType<"pow", PowNodeProperties> = createNodeType<'pow',PowNodeProperties>('pow', {shape: {base: graphTypes.nodeDefinition,exponent: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ base, exponent }: PowNodeProperties): Array<NodeDependency> {return [{target: base,until: untilNumberValueNode(PowNodeType, 'base'),},{target: exponent,until: untilNumberValueNode(PowNodeType, 'exponent'),},];},run(node: PowNode,options: never,[base, exponent]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {return value(Math.pow(base.definition.properties.value, exponent.definition.properties.value),);},},},})
Const PropertyNodeType
Property
NodeType: StatelessNodeType<"property", PropertyNodeProperties> = createNodeType<'property', PropertyNodeProperties>('property', {shape: {subject: graphTypes.nodeDefinition,path: types.arrayOf(types.string),},operations: {evaluate: {getDependencies({ subject }: PropertyNodeProperties): Array<NodeDependency> {return [{target: subject,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('Property node subject must resolve to a value() node',{expected: ValueNodeType,received: node.definition,},);},},},];},run(node: PropertyNode,options: never,[subjectNode]: [ValueNode<any>],): NodeDefinition | GraphNode {const { path } = node.definition.properties;const subject = subjectNode.definition.properties.value;return value(getPath(subject, path));},},},})
Const ProxyNodeType
Proxy
NodeType: StatelessNodeType<"proxy", ProxyNodeProperties> = createNodeType<'proxy',ProxyNodeProperties>('proxy', {shape: {middlewares: types.arrayOf(graphTypes.nodeDefinition),queryBuilder: types.saveHash(types.any),schedulerFactory: types.saveHash(types.func),},serialize: false,deserialize: false,operations: {evaluate: {run(node: ProxyNode): NodeDefinition {const { middlewares, queryBuilder, schedulerFactory } = node.definition.properties;const composedMiddleware = composeMiddlewares(transformMiddlewares(middlewares, node));let lastResult: NodeDefinition = ok();let lastSnapshot: QueriesSnapshot | undefined = undefined;return takeLast([schedulerFactory(() => {if (!queryBuilder.isModified) return lastResult;queryBuilder.resetModifiedState();const queryBuilderSnapshot = getQueryBuilderSnapshot(queryBuilder);if (lastSnapshot && isEqual(lastSnapshot, queryBuilderSnapshot)) return lastResult;lastSnapshot = queryBuilderSnapshot;const querySetWithCallback = buildQuerySetFromQueryBuilderSnapshot(queryBuilderSnapshot,queryBuilder,);const traverseRequest = traverse(composedMiddleware,requestOperation(querySetWithCallback.node, {}),);lastResult = resolve([{ target: traverseRequest, allowErrors: true }],([result]: [GraphNode]) => {querySetWithCallback.callback(result.definition);return ok();},);return lastResult;}),placeholder(queryBuilder, []),]);},},},})
Const PushNodeType
Push
NodeType: StatefulNodeType<"push", PushNodeProperties, PushNodeState, __type> = createNodeType<'push', PushNodeProperties, PushNodeState, {}>('push', {shape: {item: graphTypes.nodeDefinition,target: graphTypes.nodeDefinition,},state: {memoized: types.saveHash(types.func),},getInitialState() {return {memoized: once((target: GraphNode, item: NodeDefinition) =>createGraphAction(target, pushOperation(item)),),};},operations: {evaluate: {cacheable: false,getDependencies({ target }: PushNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsPushOperation,},];},run(node: PushNode,options: never,[target]: [GraphNode],context: never,state: PushNodeState,): GraphAction {return state.memoized(target, node.definition.properties.item);},},},})
Const PushOperationType
Push
OperationType: OperationType<"push", PushProperties> = createOperationType<'push',PushProperties>('push', {cacheable: false,shape: {value: graphTypes.nodeDefinition,},})
Const QueryNodeType
Query
NodeType: StatefulNodeType<"query", QueryNodeProperties> = createNodeType<'query',QueryNodeProperties,QueryNodeState,QueryNodeData>('query', {shape: {keys: graphTypes.nodeDefinition,options: types.shape({omitNils: types.bool,}),root: graphTypes.nodeDefinition,},state: {result: types.oneOfType([graphTypes.graphNode, graphTypes.nodeDefinition]),},getInitialState(): QueryNodeState {return {result: pending(),};},operations: {evaluate: {run(node: QueryNode,operation: never,dependencies: never,context: never,state: QueryNodeState,): NodeDefinition | GraphNode {return state.result;},onSubscribe(this: NodeExecutionContext<QueryNodeState, QueryNodeData>,node: QueryNode,): void {let previousResponse: NodeDefinition | undefined;try {const { querySet, responseAssembler } = buildQuerySetForQuery(node.definition.properties);this.setData({disposeQuerySetSubscription: node.scope.store.subscribe(withScopeFrom(node, querySet),resolveOperation(),(response) => {if (ErrorNodeType.is(response) || PendingNodeType.is(response)) {this.setState({result: response,});return;}const newResponse = safelyGetValueFromResponse(response, responseAssembler);if (previousResponse && newResponse.type === previousResponse.type) {if (isValueNodeDefinition(newResponse) &&isValueNodeDefinition(previousResponse) &&isEqual(newResponse.properties.value, previousResponse.properties.value)) {return;}}previousResponse = newResponse;this.setState({result: newResponse,});},),});} catch (ex) {this.setState({result: isErrorNodeDefinition(ex) ? ex : error(ex),});}},onUnsubscribe(this: NodeExecutionContext<QueryNodeState, QueryNodeData>): void {const { disposeQuerySetSubscription } = this.getData();disposeQuerySetSubscription && disposeQuerySetSubscription();},},},})
Const QuerySetCallOperationNodeType
Query
SetCallOperationNodeType: StatelessNodeType<"query-set-call-operation", QuerySetCallOperationNodeProperties> = createNodeType<'query-set-call-operation', QuerySetCallOperationNodeProperties>('query-set-call-operation',{shape: {operation: graphTypes.graphOperation,},operations: {},},)
Const QuerySetCatchErrorNodeType
Query
SetCatchErrorNodeType: StaticNodeType<"query-set-catch-error", QuerySetCatchErrorNodeProperties> = createNodeType<'query-set-catch-error', QuerySetCatchErrorNodeProperties>('query-set-catch-error',{deserialize: false,serialize: false,shape: {fallbackGenerator: types.saveHash(types.func),target: graphTypes.nodeDefinition,},},)
Const QuerySetDeferNodeType
Query
SetDeferNodeType: StaticNodeType<"query-set-defer", QuerySetDeferNodeProperties> = createNodeType<'query-set-defer', QuerySetDeferNodeProperties>('query-set-defer', {deserialize: false,serialize: false,shape: {fallbackGenerator: types.saveHash(types.func),target: graphTypes.nodeDefinition,},})
Const QuerySetGetChildOperationNodeType
Query
SetGetChildOperationNodeType: StaticNodeType<"query-set-get-child-operation", QuerySetGetChildOperationNodeProperties> = createNodeType<'query-set-get-child-operation', QuerySetGetChildOperationNodeProperties>('query-set-get-child-operation',{shape: {children: types.optional(types.arrayOf(graphTypes.nodeDefinition)),operation: graphTypes.graphOperation,},},)
Const QuerySetGetItemsOperationNodeType
Query
SetGetItemsOperationNodeType: StaticNodeType<"query-set-get-items-operation", QuerySetGetItemsOperationNodeProperties> = createNodeType<'query-set-get-items-operation', QuerySetGetItemsOperationNodeProperties>('query-set-get-items-operation',{shape: {children: types.optional(types.arrayOf(graphTypes.nodeDefinition)),operation: graphTypes.graphOperation,},},)
Const QuerySetIsPendingNodeType
Query
SetIsPendingNodeType: StaticNodeType<"query-set-is-pending", QuerySetIsPendingNodeProperties> = createNodeType<'query-set-is-pending', QuerySetIsPendingNodeProperties>('query-set-is-pending',{deserialize: false,serialize: false,shape: {target: graphTypes.nodeDefinition,},},)
Const QuerySetNodeType
Query
SetNodeType: StatelessNodeType<"query-set", QuerySetNodeProperties> = createNodeType<'query-set', QuerySetNodeProperties>('query-set', {shape: {children: types.optional(types.arrayOf(graphTypes.nodeDefinition)),options: types.shape({bubbleErrorsToTop: types.bool,omitNils: types.bool,}),root: graphTypes.nodeDefinition,},operations: {evaluate: {run(node: QuerySetNode): NodeDefinition {const { children, options, root } = node.definition.properties;return resolveOperations(withScopeFrom(node, root), children, withScopeFrom(node,value(options),) as ValueNode<QuerySetOptions>);},},},})
Const QuerySetOperationNodeType
Query
SetOperationNodeType: StaticNodeType<"query-set-operation", QuerySetOperationNodeProperties> = createNodeType<'query-set-operation', QuerySetOperationNodeProperties>('query-set-operation', {shape: {children: types.optional(types.arrayOf(graphTypes.nodeDefinition)),operation: graphTypes.graphOperation,},})
Const QuerySetResultNodeType
Query
SetResultNodeType: StatefulNodeType<"query-set-result", QuerySetResultNodeProperties, QuerySetResultNodeState, QuerySetResultNodeData> = createNodeType<'query-set-result',QuerySetResultNodeProperties,QuerySetResultNodeState,QuerySetResultNodeData>('query-set-result', {shape: {queries: types.arrayOf(graphTypes.nodeDefinition),result: graphTypes.nodeDefinition,},state: {},getInitialState() {return {};},operations: {call: {run(node: QuerySetResultNode, operation: CallOperation): NodeDefinition {const { queries, result } = node.definition.properties;const queryIndex = queries.findIndex((query) =>isQuerySetCallOperationNodeDefinition(query) &&query.properties.operation.id === operation.id,);if (queryIndex === -1) {return error(`Could not find 'call' result for operation: ${operation.id}`);}const query = queries[queryIndex] as QuerySetOperationNodeDefinition;const queryResult = result.properties.items[queryIndex];if (!query.properties.children) {return queryResult;}if (!isArrayNodeDefinition(queryResult)) {return error(getInvalidTypeErrorMessage('Invalid query result', {expected: ArrayNodeType,received: queryResult,}),);}return querySetResult(query.properties.children, queryResult);},},evaluate: {run(node: QuerySetResultNode): NodeDefinition {const { queries, result } = node.definition.properties;const queryIndex = queries.findIndex((query) =>isQuerySetOperationNodeDefinition(query) &&(isEvaluateOperation(query.properties.operation) ||isResolveOperation(query.properties.operation)),);if (queryIndex === -1) {return error('Node does not support `evaluate` operation.');}const query = queries[queryIndex] as QuerySetOperationNodeDefinition;const queryResult = result.properties.items[queryIndex];if (!query.properties.children) {return queryResult;}if (!isArrayNodeDefinition(queryResult)) {return error(getInvalidTypeErrorMessage('Invalid query result', {expected: ArrayNodeType,received: queryResult,}),);}return querySetResult(query.properties.children, queryResult);},},getChild: {run(node: QuerySetResultNode, operation: GetChildOperation): NodeDefinition {const { queries, result } = node.definition.properties;const queryIndex = queries.findIndex((query) =>isQuerySetGetChildOperationNodeDefinition(query) &&query.properties.operation.id === operation.id,);if (queryIndex === -1) {const { key } = operation.properties;return notFound(`Could not find 'getChild' result for key: ${getType(key)}`);}const query = queries[queryIndex] as QuerySetGetChildOperationNodeDefinition;const queryResult = result.properties.items[queryIndex];if (!query.properties.children) {return queryResult;}if (!isArrayNodeDefinition(queryResult)) {return error(getInvalidTypeErrorMessage('Invalid query result', {expected: ArrayNodeType,received: queryResult,}),);}return querySetResult(query.properties.children, queryResult);},},getItems: {run(node: QuerySetResultNode, operation: GetItemsOperation): NodeDefinition {const { queries, result } = node.definition.properties;const queryIndex = queries.findIndex((query) =>isQuerySetGetItemsOperationNodeDefinition(query) &&(query.properties.operation? query.properties.operation.id === operation.id: operation.properties.transforms.length === 0),);if (queryIndex === -1) {return error(`Could not find 'getItems' result for operation: ${operation.id}.`);}const query = queries[queryIndex] as QuerySetGetItemsOperationNodeDefinition;const queryResult = result.properties.items[queryIndex];if (!query.properties.children) {return queryResult;}if (!isArrayNodeDefinition(queryResult)) {return error(getInvalidTypeErrorMessage('Invalid query result', {expected: ArrayNodeType,received: queryResult,}),);}return querySetResult(query.properties.children, queryResult);},},set: {run(node: QuerySetResultNode, operation: CallOperation): NodeDefinition {const { queries, result } = node.definition.properties;const queryIndex = queries.findIndex((query) =>isQuerySetSetOperationNodeDefinition(query) &&query.properties.operation.id === operation.id,);if (queryIndex === -1) {return error(`Could not find 'set' result for operation: ${operation.id}`);}const query = queries[queryIndex] as QuerySetGetItemsOperationNodeDefinition;const queryResult = result.properties.items[queryIndex];if (!query.properties.children) {return queryResult;}if (!isArrayNodeDefinition(queryResult)) {return error(getInvalidTypeErrorMessage('Invalid query result', {expected: ArrayNodeType,received: queryResult,}),);}return querySetResult(query.properties.children, queryResult);},},},})
Const QuerySetSetOperationNodeType
Query
SetSetOperationNodeType: StatelessNodeType<"query-set-set-operation", QuerySetSetOperationNodeProperties> = createNodeType<'query-set-set-operation', QuerySetSetOperationNodeProperties>('query-set-set-operation',{shape: {operation: graphTypes.graphOperation,},operations: {},},)
Const ROOT_CONTEXT_NAME
ROOT_CONTEXT_NAME: unique symbol = Symbol('ROOT')
Const ReduceNodeType
Reduce
NodeType: StatelessNodeType<"reduce", ReduceNodeProperties> = createNodeType<'reduce',ReduceNodeProperties>('reduce', {shape: {source: types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode]),reducer: types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode]),initialState: types.any,},operations: {evaluate: {getDependencies({ source }: ReduceNodeProperties): Array<NodeDependency> {return [{target: source,until: untilSupportsIterateOperation,},];},run(node: ReduceNode, options: never, [iterable]: [GraphNode]): NodeDefinition {const { initialState, reducer } = node.definition.properties;return getNextIteratorResult(iterable, (iteratorResult) => {if (NilNodeType.is(iteratorResult)) {return withScopeFrom(iterable, value(initialState));}const { value: itemValue, next: nextIterator } = iteratorResult.definition.properties;const item = isGraphNode(itemValue)? itemValue: withScopeFrom(iteratorResult, itemValue);return withScopeFrom(iteratorResult,applyReducerStep(reducer, initialState, item, (transformedResult) => {if (DoneNodeType.is(transformedResult)) {const resultValue = transformedResult.definition.properties.value!;return withScopeFrom(transformedResult,resolve([{target: resultValue,until: untilValidReducerStep,},],([finalValue]: [ValueNode<any>]) => finalValue,),);}const { value: updatedState } = transformedResult.definition.properties;if (!nextIterator) {return withScopeFrom(transformedResult, value(updatedState));}const nextIteratorNode = isGraphNode(nextIterator)? nextIterator: withScopeFrom(iteratorResult, nextIterator);const nextResult = reduce(nextIteratorNode, reducer, updatedState);return withScopeFrom(node, nextResult);}),);});},},},})
Const RegexNodeType
Regex
NodeType: StaticNodeType<"regex", RegexNodeProperties, SerializedRegexNodeProperties> = createNodeType<'regex', RegexNodeProperties, SerializedRegexNodeProperties>('regex', {shape: {pattern: types.oneOfType([types.string, types.saveHash(types.any)]),},serialize(properties: RegexNodeProperties): SerializedRegexNodeProperties {return {pattern: { source: properties.pattern.source, flags: properties.pattern.flags },};},deserialize(properties: SerializedRegexNodeProperties): RegexNodeProperties {return {pattern: new RegExp(properties.pattern.source, properties.pattern.flags),};},})
Const RemoteMiddlewareNodeTypes
Remote
MiddlewareNodeTypes: Array<NodeType> = [// CacheMiddlewareNodeType,CombinedMiddlewareNodeType,FromStreamMiddlewareNodeType,MockResponseMiddlewareNodeType,TransformResponseMiddlewareNodeType,XhrMiddlewareNodeType,]
Const RemoteNodeTypes
Remote
NodeTypes: Array<NodeType> = [...RemoteMiddlewareNodeTypes, ProxyNodeType]
Const RemoveItemAtNodeType
Remove
ItemAtNodeType: StatefulNodeType<"remove-item-at", RemoveItemAtNodeProperties, RemoveItemAtNodeState, __type> = createNodeType<'remove-item-at', RemoveItemAtNodeProperties, RemoveItemAtNodeState, {}>('remove-item-at',{shape: {index: graphTypes.nodeDefinition,target: graphTypes.nodeDefinition,},state: {memoized: types.saveHash(types.func),},getInitialState() {return {memoized: once((target: GraphNode, index: number) =>createGraphAction(target, removeItemAtOperation(index)),),};},operations: {evaluate: {cacheable: false,getDependencies({ target, index }: RemoveItemAtNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsRemoveItemAtOperation,},{target: index,until: untilPositiveValueIndex,},];},run(node: RemoveItemAtNode,options: never,[target, index]: [GraphNode, ValueNode<number>],context: never,state: RemoveItemAtNodeState,): GraphAction {return state.memoized(target, index.definition.properties.value);},},},},)
Const RemoveItemAtOperationType
Remove
ItemAtOperationType: OperationType<"removeItemAt", RemoveItemAtProperties> = createOperationType<'removeItemAt', RemoveItemAtProperties>('removeItemAt', {cacheable: false,shape: {index: types.number,},})
Const RemoveItemNodeType
Remove
ItemNodeType: StatefulNodeType<"remove-item", RemoveItemNodeProperties, RemoveItemNodeState, __type> = createNodeType<'remove-item', RemoveItemNodeProperties, RemoveItemNodeState, {}>('remove-item',{shape: {item: graphTypes.nodeDefinition,target: graphTypes.nodeDefinition,},state: {memoized: types.saveHash(types.func),},getInitialState() {return {memoized: lodashOnce((target: GraphNode, id: string) =>createGraphAction(target, removeItemOperation(id)),),};},operations: {evaluate: {cacheable: false,getDependencies({ target, item }: RemoveItemNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsRemoveItemOperation,},{target: once({target: item,until: untilItemWithId,}),until: untilItemWithId,},];},run(node: RemoveItemNode,options: never,[target, item]: [GraphNode, ItemWithIdNode],context: never,state: RemoveItemNodeState,): GraphAction {return state.memoized(target, item.definition.properties.id);},},},},)
Const RemoveItemOperationType
Remove
ItemOperationType: OperationType<"removeItem", RemoveItemProperties> = createOperationType<'removeItem', RemoveItemProperties>('removeItem', {cacheable: false,shape: {id: types.string,},})
Const RemoveItemsNodeType
Remove
ItemsNodeType: StatefulNodeType<"remove-items", RemoveItemsNodeProperties, RemoveItemsNodeState, __type> = createNodeType<'remove-items', RemoveItemsNodeProperties, RemoveItemsNodeState, {}>('remove-items',{shape: {predicate: graphTypes.nodeDefinition,target: graphTypes.nodeDefinition,},state: {memoized: types.saveHash(types.func),},getInitialState() {return {memoized: once((target: GraphNode, predicate: NodeDefinition) =>createGraphAction(target, removeItemsOperation(predicate)),),};},operations: {evaluate: {cacheable: false,getDependencies({ target, predicate }: RemoveItemsNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsRemoveItemsOperation,},];},run(node: RemoveItemsNode,operation: never,[target]: [GraphNode],context: never,state: RemoveItemsNodeState,): GraphAction {const { predicate } = node.definition.properties;return state.memoized(target, predicate);},},},},)
Const RemoveItemsOperationType
Remove
ItemsOperationType: OperationType<"removeItems", RemoveItemsProperties> = createOperationType<'removeItems', RemoveItemsProperties>('removeItems', {cacheable: false,shape: {predicate: graphTypes.nodeDefinition,},})
Const ReplaceNodeType
Replace
NodeType: StatelessNodeType<"replace", ReplaceNodeProperties> = createNodeType<'replace',ReplaceNodeProperties>('replace', {shape: {pattern: graphTypes.nodeDefinition,replacePattern: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({pattern,replacePattern,subject,}: ReplaceNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(ReplaceNodeType, 'subject'),},{target: pattern,until: untilStringValueNode(ReplaceNodeType, 'pattern'),},{target: replacePattern,until: untilStringValueNode(ReplaceNodeType, 'replacePattern'),},];},run(node: ReplaceNode,options: never,[subject, pattern, replacePattern]: Array<ValueNode<string>>,): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;const patternValue = pattern.definition.properties.value;const replacePatternValue = replacePattern.definition.properties.value;return value((subjectValue || '').replace(patternValue, replacePatternValue));},},},})
Const RequestOperationType
Request
OperationType: OperationType<"request", RequestProperties> = createOperationType<'request', RequestProperties>('request', {shape: {metadata: types.objectOf(types.saveHash(types.any)),next: types.optional(graphTypes.graphNode),query: graphTypes.nodeDefinition,},})
Const ResetNodeType
Reset
NodeType: StatelessNodeType<"reset", ResetNodeProperties> = createNodeType<'reset',ResetNodeProperties>('reset', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {cacheable: false,getDependencies({ target }: ResetNodeProperties): [NodeDependency] {return [{target,until: {predicate: supportsResetOperation,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage(`${pascalCase(ResetNodeType.name)} target cannot be reset`,{ received: node.definition },);},},},];},run(node: ResetNode, operation: never, [subjectNode]: [ResettableGraphNode]): GraphAction {return createGraphAction(subjectNode, resetOperation());},},},})
Const ResetOperationType
Reset
OperationType: OperationType<"reset"> = createOperationType('reset', {cacheable: false,})
Const ResolveOperationType
Resolve
OperationType: OperationType<"resolve", ResolveProperties> = createOperationType<'resolve', ResolveProperties>('resolve', {shape: {until: types.optional(types.shape({predicate: types.saveHash(types.func),errorMessage: types.saveHash(types.func),}),),allowErrors: types.bool,allowPending: types.bool,acceptNil: types.bool,},})
Const ResultOperationType
Result
OperationType: OperationType<"result", ResultProperties<any>> = createOperationType<'result', ResultProperties<any>>('result', {shape: {acc: types.saveHash(types.any),next: types.optional(graphTypes.graphNode),},})
Const RootNodeType
Root
NodeType: StatelessNodeType<"root"> = createNodeType<'root'>('root', {operations: {evaluate: {run(node: RootNode): GraphNode {return node.context.values[ROOT_CONTEXT_NAME as any];},},},})
Const RoundNodeType
Round
NodeType: StatelessNodeType<"round", RoundNodeProperties> = createNodeType<'round',RoundNodeProperties>('round', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: RoundNodeProperties): Array<NodeDependency> {return [{ target, until: untilNumberValueNode(RoundNodeType, 'target') }];},run(node: RoundNode, options: never, [target]: [ValueNode<number>]): NodeDefinition {return toValue(Math.round(target.definition.properties.value));},},},})
Const SCOPE
SCOPE: unique symbol = Symbol.for('muster::SCOPE')
Const ScopeNodeType
Scope
NodeType: StatefulNodeType<"scope", ScopeNodeProperties, ScopeNodeState, ScopeNodeData> = createNodeType<'scope', ScopeNodeProperties, ScopeNodeState, ScopeNodeData>('scope', {shape: {context: types.optional(types.objectOf(types.oneOfType<NodeDefinition | GraphNode>([graphTypes.nodeDefinition,graphTypes.graphNode,]),),),root: graphTypes.nodeDefinition,redispatch: types.optional(types.oneOfType([types.saveHash(types.func), types.bool])),},state: {scope: types.optional(graphTypes.scope),context: types.optional(graphTypes.context),},getInitialState() {return {scope: undefined,context: undefined,};},onSubscribe(this: NodeExecutionContext<ScopeNodeState, ScopeNodeData>, node: ScopeNode): void {const { root, context, redispatch } = node.definition.properties;const childScope = createChildScope(node.scope, {redispatch,onSubscribe: () => this.retain(),onUnsubscribe: () => this.release(),});const childContext = createRootContext({...(context &&mapValues(context, (contextValue) =>isGraphNode(contextValue) ? contextValue : withScopeFrom(node, contextValue),)),[PARENT_SCOPE_PATH_KEY]: withScopeFrom(node, value(getPath(node.context))),});// TODO: Remove the `as any` cast once https://github.com/Microsoft/TypeScript/issues/1863 is resolvedchildContext.values[ROOT_CONTEXT_NAME as any] = createGraphNode(childScope, childContext, root);this.setState((prevState): ScopeNodeState => ({...prevState,scope: childScope,context: childContext,}),);const scopeDefinition = node.definition as ScopeNodeDefinition;scopeDefinition.activeScopes.push(childScope);},onUnsubscribe(this: NodeExecutionContext<ScopeNodeState, ScopeNodeData>, node: ScopeNode): void {const { scope } = this.getState();if (!scope) {return;}const scopeDefinition = node.definition as ScopeNodeDefinition;const scopeIndex = scopeDefinition.activeScopes.indexOf(scope);if (scopeIndex !== -1) {scopeDefinition.activeScopes.splice(scopeIndex, 1);}},operations: {evaluate: {run(node: ScopeNode,options: never,dependencies: Array<never>,contextDependencies: Array<never>,state: ScopeNodeState,): NodeDefinition | GraphNode {const { root } = node.definition.properties;const { scope, context } = state;return createGraphNode(scope!, context!, root);},},},})
Const SentenceCaseNodeType
Sentence
CaseNodeType: StatelessNodeType<"sentence-case", SentenceCaseNodeProperties> = createNodeType<'sentence-case', SentenceCaseNodeProperties>('sentence-case', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: SentenceCaseNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(SentenceCaseNodeType, 'subject'),},];},run(node: SentenceCaseNode, options: never, [subject]: [ValueNode<string>]): NodeDefinition {if (NilNodeType.is(subject)) return nil();return value(upperFirst(subject.definition.properties.value));},},},})
Const SeriesNodeType
Series
NodeType: StatelessNodeType<"series", SeriesNodeProperties> = createNodeType<'series',SeriesNodeProperties>('series', {shape: {operations: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {cacheable: false,getDependencies({ operations }: SeriesNodeProperties): Array<NodeDependency> {return operations.length > 0 ? [{ target: operations[0], once: true }] : [];},run(node: SeriesNode, options: never, [result]: [GraphNode]): NodeDefinition {const operations = node.definition.properties.operations;if (operations.length === 0) return value(undefined);if (operations.length === 1) return once(result.definition);return series(operations.slice(1));},},},})
Const SetNodeType
Set
NodeType: StatelessNodeType<"set", SetNodeProperties> = createNodeType<'set',SetNodeProperties>('set', {shape: {target: graphTypes.nodeDefinition,value: graphTypes.nodeDefinition,},operations: {evaluate: {cacheable: false,getDependencies({ target }: SetNodeProperties): [NodeDependency] {return [{target,until: untilSupportsSetOperation,},];},run(node: SetNode, operation: never, [targetNode]: [SettableGraphNode]): GraphAction {const { value } = node.definition.properties;return createGraphAction(targetNode, setOperation(value));},},},})
Const SetOperationType
Set
OperationType: OperationType<"set", SetProperties> = createOperationType<'set',SetProperties>('set', {cacheable: false,shape: {value: graphTypes.nodeDefinition,},})
Const SetResultNodeType
Set
ResultNodeType: StatelessNodeType<"setResult", SetResultNodeProperties> = createNodeType<'setResult', SetResultNodeProperties>('setResult', {shape: {target: graphTypes.nodeDefinition,value: graphTypes.nodeDefinition,},operations: {evaluate: {cacheable: false,getDependencies({ target, value }: SetResultNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsSetOperation,},{target: value,},];},run(node: SetResultNode,operation: never,[targetNode, value]: [SettableGraphNode, GraphNode],): GraphAction {return createGraphAction(targetNode, setOperation(value.definition));},},},})
Const ShiftNodeType
Shift
NodeType: StatefulNodeType<"shift", ShiftNodeProperties, ShiftNodeState, __type> = createNodeType<'shift', ShiftNodeProperties, ShiftNodeState, {}>('shift', {shape: {id: types.number,target: graphTypes.nodeDefinition,},state: {currentValue: types.optional(graphTypes.nodeDefinition),},getInitialState() {return {currentValue: undefined,};},operations: {evaluate: {cacheable: false,run(node: ShiftNode,options: never,dependencies: never,context: never,state: ShiftNodeState,): GraphNode {return state.currentValue!;},onSubscribe(this: NodeExecutionContext<ShiftNodeState, {}>, node: ShiftNode): void {if (this.getState().currentValue) return;const { target } = node.definition.properties;this.setState(() => ({currentValue: withScopeFrom(node,resolve([{ target, until: untilSupportsShiftOperation }], ([resolvedTarget]) => {return withScopeFrom(resolvedTarget,resolve([createGraphAction(resolvedTarget, shiftOperation())], ([result]) => {this.setState(() => ({ currentValue: result }));return result;}),);}),),}));},},},})
Const ShiftOperationType
Shift
OperationType: OperationType<"shift", ShiftProperties> = createOperationType<'shift',ShiftProperties>('shift', {cacheable: false,shape: {},})
Const SkipNodeType
Skip
NodeType: StatelessNodeType<"skip", SkipNodeProperties> = createNodeType('skip', {shape: {offset: graphTypes.nodeDefinition,},operations: {transformItems: {getDependencies({ offset }: SkipNodeProperties): Array<NodeDependency> {return [{target: offset,until: untilPositiveIntegerOffset,},];},run(node: SkipNode,operation: TransformItemsOperation,[offset]: [ValueNode<number>],): NodeDefinition {const { value: offsetValue } = offset.definition.properties;return nodeList(operation.properties.items.slice(offsetValue));},},init: {run(node: SkipNode, operation: InitOperation): NodeDefinition {const { next } = operation.properties;if (!next) {return error('Skip reducer cannot be used as a base reducer');}return withReducerState(0, traverse(next, init()));},},step: {getDependencies({ offset }: SkipNodeProperties): Array<NodeDependency> {return [{target: offset,until: untilPositiveIntegerOffset,},];},run(node: SkipNode,operation: StepOperation<[any, number]>,[offset]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {const { acc, item, next } = operation.properties;if (!next) {return error('Skip reducer cannot be used as a base reducer');}const [items, currentIndex] = acc;const { value: firstIndex } = offset.definition.properties;if (currentIndex < firstIndex) {return withReducerState(currentIndex + 1, value(items));}return withReducerState(currentIndex, traverse(next, step(items, item)));},},result: {run(node: SkipNode, operation: ResultOperation<[any, number]>): NodeDefinition | GraphAction {const { acc, next } = operation.properties;if (!next) {return error('Skip reducer cannot be used as a base reducer');}const [items] = acc;return createGraphAction(next, result(items));},},},})
Const SliceNodeType
Slice
NodeType: StatelessNodeType<"slice", SliceNodeProperties> = createNodeType('slice',{shape: {offset: graphTypes.nodeDefinition,length: graphTypes.nodeDefinition,},operations: {transformItems: {getDependencies({ offset, length }: SliceNodeProperties): Array<NodeDependency> {return [{target: offset,until: untilPositiveIntegerOffset,},{target: length,until: untilPositiveIntegerLength,},];},run(node: SliceNode,operation: TransformItemsOperation,[offset, length]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {const { items } = operation.properties;const { value: offsetValue } = offset.definition.properties;const { value: lengthValue } = length.definition.properties;return nodeList(items.slice(offsetValue, offsetValue + lengthValue));},},init: {run(node: SliceNode, operation: InitOperation): NodeDefinition {const { next } = operation.properties;if (!next) {return error('Slice reducer cannot be used as a base reducer');}return withReducerState(0, traverse(next, init()));},},step: {getDependencies({ offset, length }: SliceNodeProperties): Array<NodeDependency> {return [{target: offset,until: untilPositiveIntegerOffset,},{target: length,until: untilPositiveIntegerLength,},];},run(node: SliceNode,operation: StepOperation<[any, number]>,[offset, length]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {const { acc, item, next } = operation.properties;if (!next) {return error('Slice reducer cannot be used as a base reducer');}const [items, currentIndex] = acc;const firstIndex = offset.definition.properties.value;const lastIndex = firstIndex + length.definition.properties.value - 1;if (currentIndex < firstIndex) {return withReducerState(currentIndex + 1, value(items));}if (currentIndex > lastIndex) {return done(withReducerState(currentIndex + 1, value(items)));}const nextValue = withReducerState(currentIndex + 1, traverse(next, step(items, item)));return currentIndex === lastIndex ? done(nextValue) : nextValue;},},result: {run(node: SliceNode,operation: ResultOperation<[any, number]>,): NodeDefinition | GraphAction {const { acc, next } = operation.properties;if (!next) {return error('Slice reducer cannot be used as a base reducer');}const [items] = acc;return createGraphAction(next, result(items));},},},},)
Const SortNodeType
Sort
NodeType: StatelessNodeType<"sort", SortNodeProperties> = createNodeType('sort', {shape: {order: types.arrayOf(graphTypes.nodeDefinition),},operations: {transformItems: {getDependencies({ order }: SortNodeProperties): Array<NodeDependency> {return order.map((item) => ({target: item,until: untilIsSortOrderNode,}));},run(node: SortNode,operation: TransformItemsOperation,orderNodes: Array<SortOrderNode>,): NodeDefinition {const { items } = operation.properties;const descending = orderNodes.map((orderNode) => orderNode.definition.properties.descending,);return resolve(flatMap(items, (item) =>orderNodes.map((order) => ({target: apply([item], order),until: untilIsValidSortValue,})),),(combinedSortValueNodes: Array<ValueNode<SortValue>>) => {const combinedSortValues = combinedSortValueNodes.map((node) => node.definition.properties.value,);const itemSortValues = chunk(combinedSortValues, orderNodes.length);const sortedItems = (zip<GraphNode | Array<SortValue>>(items, itemSortValues) as Array<[GraphNode, Array<SortValue>]>).sort(([item1, sortValues1], [item2, sortValues2]) =>compareSortValues(sortValues1, sortValues2, descending),).map(([item]) => item);return withScopeFrom(node, nodeList(sortedItems));},);},},init: {run(node: SortNode): NodeDefinition {const initialState = [] as Array<GraphNode>;return value(initialState);},},step: {run(node: SortNode, operation: StepOperation<Array<GraphNode>>): NodeDefinition {const { acc, item } = operation.properties;return value([...acc, item]);},},result: {getDependencies({ order }: SortNodeProperties): Array<NodeDependency> {return order.map((iteratee) => ({target: iteratee,until: untilIsSortOrderNode,}));},run(node: SortNode,operation: ResultOperation<Array<GraphNode>>,orderNodes: Array<SortOrderNode>,): NodeDefinition {const { acc, next } = operation.properties;if (!next) {return error('Sort reducer cannot be used as a base reducer');}const descending = orderNodes.map((orderNode) => orderNode.definition.properties.descending,);const sortedItems = resolve(flatMap(acc, (item) =>orderNodes.map((order) => ({target: apply([item], order.definition.properties.iteratee),until: untilIsValueNode,})),),(orderResults: Array<ValueNode<SortValue>>) => {const itemsWithSortValues = acc.map((item, itemIndex) =>[item,orderNodes.map((order, orderIndex) =>orderResults[itemIndex * orderNodes.length + orderIndex].definition.properties.value,),] as [GraphNode, Array<SortValue>],);const sortedItems = itemsWithSortValues.sort(([, sortValues1], [, sortValues2]) => {return compareSortValues(sortValues1, sortValues2, descending);}).map(([item]) => item);return withScopeFrom(node, nodeList(sortedItems));},);return value(transduce(sortedItems, [next]));},},},})
Const SortOrderNodeType
Sort
OrderNodeType: StatelessNodeType<"sortOrder", SortOrderNodeProperties> = createNodeType('sortOrder', {shape: {iteratee: graphTypes.nodeDefinition,descending: types.bool,},operations: {call: {getDependencies({ iteratee }: SortOrderNodeProperties,operation: CallOperation,): Array<NodeDependency> {return [{target: apply(operation.properties.args!, iteratee),until: untilIsValidSortValue,},];},run(node: SortOrderNode, operation: CallOperation, [result]: [GraphNode]): GraphNode {return result;},},},})
Const SplitNodeType
Split
NodeType: StatelessNodeType<"split", SplitNodeProperties> = createNodeType<'split',SplitNodeProperties>('split', {shape: {limit: types.optional(graphTypes.nodeDefinition),separator: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ limit, separator, subject }: SplitNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(SplitNodeType, 'subject'),},{target: separator,until: untilStringValueNode(SplitNodeType, 'separator'),},...(limit? [{ target: limit, until: untilPositiveIntegerValueNode(SplitNodeType, 'limit') }]: []),];},run(node: SplitNode,options: never,[subject, separator, ...rest]: [ValueNode<string>, ValueNode<string>, ValueNode<number>],): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;const separatorValue = separator.definition.properties.value;const limitValue =rest.length === 1 ? (rest[0].definition.properties.value as number) : undefined;return array(subjectValue.split(separatorValue, limitValue).map(value));},},},})
Const SqrtNodeType
Sqrt
NodeType: StatelessNodeType<"sqrt", SqrtNodeProperties> = createNodeType<'sqrt',SqrtNodeProperties>('sqrt', {shape: {operand: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ operand }: SqrtNodeProperties): Array<NodeDependency> {return [{target: operand,until: untilNumberValueNode(SqrtNodeType, 'base'),},];},run(node: SqrtNode, options: never, [operand]: [ValueNode<number>]): NodeDefinition {return value(Math.sqrt(operand.definition.properties.value));},},},})
Const StartCaseNodeType
Start
CaseNodeType: StatelessNodeType<"start-case", StartCaseNodeProperties> = createNodeType<'start-case', StartCaseNodeProperties>('start-case', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: StartCaseNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(StartCaseNodeType, 'subject'),},];},run(node: StartCaseNode, options: never, [subject]: [ValueNode<string>]): NodeDefinition {if (NilNodeType.is(subject)) return nil();return value(lodashStartCase(subject.definition.properties.value));},},},})
Const StartsWithNodeType
Starts
WithNodeType: StatelessNodeType<"starts-with", StartsWithNodeProperties> = createNodeType<'starts-with', StartsWithNodeProperties>('starts-with', {shape: {pattern: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ pattern, subject }: StartsWithNodeProperties): Array<NodeDependency> {return [{target: pattern,until: untilStringValueNode(StartsWithNodeType, 'pattern'),},{target: subject,acceptNil: true,until: untilStringValueNode(StartsWithNodeType, 'subject'),},];},run(node: StartsWithNode,options: never,[pattern, subject]: [ValueNode<string>, ValueNode<string>],): NodeDefinition {if (NilNodeType.is(subject)) return value(false);const patternValue = pattern.definition.properties.value;const subjectValue = subject.definition.properties.value;return value((subjectValue || '').startsWith(patternValue));},},},})
Const StepOperationType
Step
OperationType: OperationType<"step", StepProperties<any>> = createOperationType<'step',StepProperties<any>>('step', {shape: {acc: types.optional(types.saveHash(types.any)),item: graphTypes.graphNode,next: types.optional(graphTypes.graphNode),},})
Const StringNodeTypes
String
NodeTypes: Array<NodeType> = [CharAtNodeType,EndsWithNodeType,FormatNodeType,FromBase64NodeType,IncludesNodeType,JoinNodeType,LowerCaseNodeType,MatchPatternNodeType,ParseFloatNodeType,ParseIntNodeType,RegexNodeType,ReplaceNodeType,SentenceCaseNodeType,SplitNodeType,StartCaseNodeType,StartsWithNodeType,SubstringNodeType,TestNodeType,ToBase64NodeType,ToStringNodeType,TrimNodeType,TruncateNodeType,UpperCaseNodeType,]
Const SubstringNodeType
Substring
NodeType: StatelessNodeType<"substring", SubstringNodeProperties> = createNodeType<'substring', SubstringNodeProperties>('substring', {shape: {endIndex: types.optional(graphTypes.nodeDefinition),startIndex: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({endIndex,startIndex,subject,}: SubstringNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(SubstringNodeType, 'subject'),},{target: startIndex,until: untilPositiveIntegerValueNode(SubstringNodeType, 'startIndex'),},...(endIndex? [{target: endIndex,until: untilPositiveIntegerValueNode(SubstringNodeType, 'endIndex'),},]: []),];},run(node: SubstringNode,options: never,[subject, startIndex, endIndex]: [ValueNode<string>, ValueNode<number>, ValueNode<number>],): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;const startIndexValue = startIndex.definition.properties.value;const endIndexValue = endIndex ? endIndex.definition.properties.value : undefined;if (startIndexValue > subjectValue.length) return value('');return value(subjectValue.substring(startIndexValue, endIndexValue));},},},})
Const SubtractNodeType
Subtract
NodeType: StatelessNodeType<"subtract", SubtractNodeProperties> = createNodeType<'subtract', SubtractNodeProperties>('subtract', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: SubtractNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: untilNumberValueNode(SubtractNodeType, 'operand'),}));},run(node: SubtractNode, options: never, operands: Array<ValueNode<number>>): NodeDefinition {assertEnoughOperands(operands);const operandValues = operands.map((operand) => operand.definition.properties.value);return value(operandValues.reduce((total, value) => total - value));},},},})
Const SwitchOnNodeType
Switch
OnNodeType: StatelessNodeType<"switchOn", SwitchOnNodeProperties> = createNodeType<'switchOn', SwitchOnNodeProperties>('switchOn', {shape: {input: graphTypes.nodeDefinition,options: types.arrayOf(graphTypes.nodeDefinition),fallback: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ input, options }: SwitchOnNodeProperties): Array<NodeDependency> {return [{target: input,until: untilInputIsValueNode,},...options.map((option) => ({target: option.properties.pattern,until: untilPatternIsValueNodeOrCallableNode,})),];},run(node: SwitchOnNode,operation: never,dependencies: Array<ValueNode<any> | CallableGraphNode>,): NodeDefinition {const { options, fallback } = node.definition.properties;const [input] = dependencies as [ValueNode<any>];const [, ...resolvedOptions] = dependencies;return choose([...resolvedOptions.map((option, index) =>when(ValueNodeType.is(option)? eq(input.definition, option.definition): apply([input], option),options[index].properties.value,),),fallback,]);},},},})
Const TRANSACTION_END
TRANSACTION_END: "$$event:transactionEnd" = "$$event:transactionEnd"
Const TRANSACTION_START
TRANSACTION_START: "$$event:transactionStart" = "$$event:transactionStart"
Const TYPE_HASHERS
TYPE_
HASHERS: Map<Matcher<any, any> | function, HashFunction<any> | ValueHasherFactory<any, any>> = new Map<Matcher<any, any> | ((options: any) => Matcher<any, any>),HashFunction<any> | ValueHasherFactory<any, any>>([[types.empty, empty],[types.nil, nil],[types.bool, bool],[types.number, number],[types.integer, number],[types.string, string],[types.symbol, symbol],[types.date, date],[types.func, func],[types.object, object],[types.matcher, matcher],[types.instance, instance],[types.array, array],[types.instanceOf, instanceOf],[types.any, any],[types.oneOf, oneOf],[types.shape, shape],[types.arrayOf, arrayOf],[types.objectOf, objectOf],[types.oneOfType, oneOfType],[types.ignore, ignore],[types.optional, optional],[types.saveHash, saveHash],])
Const TakeLastNodeType
Take
LastNodeType: StatefulNodeType<"takeLast", TakeLastNodeProperties, TakeLastNodeState, TakeLastNodeData> = createNodeType<'takeLast', TakeLastNodeProperties, TakeLastNodeState, TakeLastNodeData>('takeLast',{state: {},shape: {operations: types.arrayOf(graphTypes.nodeDefinition),},getInitialState(): TakeLastNodeState {return {};},operations: {evaluate: {run(node: TakeLastNode): NodeDefinition {return last(node.definition.properties.operations) || nil();},onSubscribe(this: NodeExecutionContext<TakeLastNodeState, TakeLastNodeData>,node: TakeLastNode,): void {const { operations } = node.definition.properties;const subscriptions = operations.slice(0, -1).map((operation) =>node.scope.store.subscribe(withScopeFrom(node, operation), resolveOperation(), noop),);this.setData({unsubscribe: () => subscriptions.forEach((unsubscribe) => unsubscribe()),});},onUnsubscribe(this: NodeExecutionContext<TakeLastNodeState, TakeLastNodeData>): void {const { unsubscribe } = this.getData();if (unsubscribe) {unsubscribe();}},},},},)
Const TakeNodeType
Take
NodeType: StatelessNodeType<"take", TakeNodeProperties> = createNodeType('take', {shape: {numItems: graphTypes.nodeDefinition,},operations: {transformItems: {getDependencies({ numItems }: TakeNodeProperties): Array<NodeDependency> {return [{target: numItems,until: untilPositiveNumItemsNode,},];},run(node: TakeNode,operation: TransformItemsOperation,[numItems]: [ValueNode<number>],): NodeDefinition {const { value: numItemsValue } = numItems.definition.properties;return nodeList(operation.properties.items.slice(0, numItemsValue));},},init: {run(node: TakeNode, operation: InitOperation): NodeDefinition {const { next } = operation.properties;if (!next) {return error('Take reducer cannot be used as a base reducer');}return withReducerState(0, traverse(next, init()));},},step: {getDependencies({ numItems }: TakeNodeProperties): Array<NodeDependency> {return [{target: numItems,until: untilPositiveNumItemsNode,},];},run(node: TakeNode,operation: StepOperation<[any, number]>,[numItems]: [ValueNode<number>],): NodeDefinition {const { acc, item, next } = operation.properties;if (!next) {return error('Take reducer cannot be used as a base reducer');}const [items, currentIndex] = acc;const lastIndex = numItems.definition.properties.value - 1;if (currentIndex > lastIndex) {return done(value(acc));}const nextValue = withReducerState(currentIndex + 1, traverse(next, step(items, item)));return currentIndex === lastIndex ? done(nextValue) : nextValue;},},result: {run(node: TakeNode, operation: ResultOperation<[any, number]>): NodeDefinition | GraphAction {const { acc, next } = operation.properties;if (!next) {return error('Take reducer cannot be used as a base reducer');}const [items] = acc;return createGraphAction(next, result(items));},},},})
Const TestNodeType
Test
NodeType: StatelessNodeType<"test", TestNodeProperties> = createNodeType<'test',TestNodeProperties>('test', {shape: {regex: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ regex, subject }: TestNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(TestNodeType, 'subject'),},{target: regex,until: untilRegexNode(TestNodeType, 'regex'),},];},run(node: TestNode,options: never,[subject, regex]: [ValueNode<string>, RegexNode],): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;const regexValue = regex.definition.properties.pattern;return value(regexValue.test(subjectValue));},},},})
Const ToBase64NodeType
To
Base64NodeType: StatelessNodeType<"to-base64", ToBase64NodeProperties> = createNodeType<'to-base64', ToBase64NodeProperties>('to-base64', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: ToBase64NodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(ToBase64NodeType, 'subject'),},];},run(node: ToBase64Node, options: never, [subject]: [ValueNode<string>]): NodeDefinition {if (NilNodeType.is(subject)) return nil();return value(btoa(subject.definition.properties.value));},},},})
Const ToStringNodeType
To
StringNodeType: StatelessNodeType<"to-string", ToStringNodeProperties> = createNodeType<'to-string', ToStringNodeProperties>('to-string', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: ToStringNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilValueNode(ToStringNodeType, 'subject'),},];},run(node: ToStringNode, options: never, [subject]: [ValueNode<any>]): NodeDefinition {if (NilNodeType.is(subject)) return nil();return value(lodashToString(subject.definition.properties.value));},},},})
Const TransduceNodeType
Transduce
NodeType: StatelessNodeType<"transduce", TransduceNodeProperties> = createNodeType<'transduce', TransduceNodeProperties>('transduce', {shape: {source: types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode]),reducer: types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode]),},operations: {evaluate: {getDependencies({ reducer }: TransduceNodeProperties): Array<NodeDependency> {return [{target: traverse(reducer, init()),until: untilValidInitializer,},];},run(node: TransduceNode, options: never, [initialState]: [ValueNode<any>]): NodeDefinition {const { source, reducer } = node.definition.properties;return resolve([{target: reduce(source, reducer, initialState.definition.properties.value),until: untilValidStepResult,},],([acc]: [ValueNode<any>]) =>withScopeFrom(acc,resolve([{target: traverse(reducer, result(acc.definition.properties.value)),until: untilValidResult,},],([finalValue]: [ValueNode<any>]) => finalValue.definition.properties.value,),),);},},},})
Const TransformItemsOperationType
Transform
ItemsOperationType: OperationType<"transformItems", TransformItemsProperties> = createOperationType<'transformItems', TransformItemsProperties>('transformItems', {shape: {items: types.arrayOf(graphTypes.graphNode),},})
Const TransformResponseMiddlewareNodeType
Transform
ResponseMiddlewareNodeType: StatelessNodeType<"transform-response-middleware", TransformResponseMiddlewareNodeProperties> = createNodeType('transform-response-middleware', {shape: {responseTransformer: types.saveHash(types.func),},operations: {request: {run(node: TransformResponseMiddlewareNode, operation: RequestOperation): NodeDefinition {const { metadata, next, query } = operation.properties;if (!next) {return error('TransformResponseMiddleware cannot be used as a base middleware.');}const { responseTransformer } = node.definition.properties;return resolve([{target: withScopeFrom(next,traverse(next.definition, requestOperation(query, metadata)),),allowErrors: true,},],([response]) => withScopeFrom(response, responseTransformer(response.definition)),);},},},})
Const TransformsNodeTypes
Transforms
NodeTypes: Array<NodeType> = [CountNodeType,FilterNodeType,FirstItemNodeType,LastItemNodeType,MapNodeType,NthItemNodeType,SkipNodeType,SliceNodeType,SortNodeType,SortOrderNodeType,TakeNodeType,UniqueNodeType,]
Const TreeNodeType
Tree
NodeType: StatelessNodeType<"tree", TreeNodeProperties, SerializedTreeNodeProperties> = createNodeType<'tree', TreeNodeProperties, SerializedTreeNodeProperties>('tree', {shape: {branches: types.arrayOf(types.shape({match: types.saveHash(types.any),param: types.optional(types.string),node: graphTypes.nodeDefinition,}),),},operations: {getChild: {run(node: TreeNode, operation: GetChildOperation): NodeDefinition | GraphNode {const { key } = operation.properties;const branches = node.definition.properties.branches;const matchingBranch = findBranchByKey(branches, key);if (!matchingBranch) {return notFound(`Invalid child key: ${getType(key)}`);}const { param, node: child } = matchingBranch;const childContext = createChildPathContext(node,key,param === undefined? undefined: {[getParamContextId(param)]: withScopeFrom(node, value(key)),},);return createGraphNode(node.scope, childContext, child);},},},serialize<T>(properties: TreeNodeProperties,serialize: (value: any) => any,): SerializedTreeNodeProperties<T> {const { branches } = properties;return {branches: branches.map((b) => ({match: b.param === MISSING_PARAM_NAME ? undefined : serialize(b.match),param: b.param,node: serialize(b.node),})),};},deserialize<T>(data: SerializedTreeNodeProperties<T>,deserialize: (value: any) => any,): TreeNodeProperties {return {branches: data.branches.map((b) => {const deserializedNode = deserialize(b.node);if (b.param === MISSING_PARAM_NAME) {return { param: MISSING_PARAM_NAME, node: deserializedNode, match: types.any };}return { param: b.param, node: deserializedNode, match: deserialize(b.match) };}),};},getType(properties: TreeNodeProperties, getType: (value: any) => string): string {return `${TreeNodeType.name}({ ${(properties.branches as Array<any>).map((branch) =>`${typeof branch.match === 'string'? branch.match: branch.match.name? `[${branch.match.name}]`: '*'}: ${getType(branch.node)}`,).join(', ')} })`;},})
Const TrimNodeType
Trim
NodeType: StatelessNodeType<"trim", TrimNodeProperties> = createNodeType<'trim',TrimNodeProperties>('trim', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: TrimNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(TrimNodeType, 'subject'),},];},run(node: TrimNode, options: never, [subject]: [ValueNode<string>]): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;return value((subjectValue || '').trim());},},},})
Const TruncateNodeType
Truncate
NodeType: StatelessNodeType<"truncate", TruncateNodeProperties> = createNodeType<'truncate', TruncateNodeProperties>('truncate', {shape: {length: graphTypes.nodeDefinition,omission: types.optional(graphTypes.nodeDefinition),subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({length,omission,subject,}: TruncateNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(TruncateNodeType, 'subject'),},{target: length,until: untilPositiveIntegerValueNode(TruncateNodeType, 'length'),},...(omission? [{target: omission,until: untilStringValueNode(TruncateNodeType, 'omission'),},]: []),];},run(node: TruncateNode,options: never,[subject, length, omission]: [ValueNode<string>, ValueNode<number>, ValueNode<string>],): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;const lengthValue = length.definition.properties.value;const omissionValue = omission ? omission.definition.properties.value : '…';return value(lodashTruncate(subjectValue, {length: lengthValue,omission: omissionValue,}),);},},},})
Const UniqueNodeType
Unique
NodeType: StatelessNodeType<"unique", UniqueNodeProperties> = createNodeType('unique',{shape: {predicate: graphTypes.nodeDefinition,},operations: {transformItems: {getDependencies({ predicate }: UniqueNodeProperties,operation: TransformItemsOperation,): Array<NodeDependency> {return operation.properties.items.map((item) => ({target: apply([item], predicate),until: untilIsValueNode,}));},run(node: UniqueNode,operation: TransformItemsOperation,uniqueResults: Array<ValueNode<any>>,): NodeDefinition {const { items } = operation.properties;const uniqueValues = uniqBy(uniqueResults.map((item, index) => [index, item] as [number, ValueNode<any>]),([index, item]) => valueOf(item),);return nodeList(uniqueValues.map(([index]) => items[index]));},},init: {run(node: UniqueNode, operation: InitOperation): NodeDefinition | GraphAction {const { next } = operation.properties;if (!next) {return error('Unique reducer cannot be used as a base reducer');}return createGraphAction(next, init());},},step: {run(node: UniqueNode, operation: StepOperation<Array<GraphNode>>): NodeDefinition {const { acc, item } = operation.properties;return value([...acc, item]);},},result: {run(node: UniqueNode, operation: ResultOperation<any>): NodeDefinition | GraphAction {const { acc, next } = operation.properties;if (!next) {return error('Unique reducer cannot be used as a base reducer');}const uniqueItems = resolve(acc.map((item: GraphNode) => ({target: apply([item], node.definition.properties.predicate),until: untilIsValueNode,})),(predicateResults: Array<ValueNode<any>>) => {const uniqueValues = uniqBy(predicateResults.map((item, index) => [index, item] as [number, ValueNode<any>]),([index, item]) => valueOf(item),);return nodeList(uniqueValues.map(([index]) => acc[index]));},);return value(transduce(uniqueItems, [next]));},},},},)
Const UnshiftNodeType
Unshift
NodeType: StatefulNodeType<"unshift", UnshiftNodeProperties, UnshiftNodeState, __type> = createNodeType<'unshift', UnshiftNodeProperties, UnshiftNodeState, {}>('unshift', {shape: {item: graphTypes.nodeDefinition,target: graphTypes.nodeDefinition,},state: {memoized: types.saveHash(types.func),},getInitialState() {return {memoized: once((target: GraphNode, item: NodeDefinition) =>createGraphAction(target, unshiftOperation(item)),),};},operations: {evaluate: {cacheable: false,getDependencies({ target }: UnshiftNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsUnshiftOperation,},];},run(node: UnshiftNode,options: never,[target]: [GraphNode],context: never,state: UnshiftNodeState,): GraphAction {return state.memoized(target, node.definition.properties.item);},},},})
Const UnshiftOperationType
Unshift
OperationType: OperationType<"unshift", UnshiftProperties> = createOperationType<'unshift', UnshiftProperties>('unshift', {cacheable: false,shape: {value: graphTypes.nodeDefinition,},})
Const UpdateNodeType
Update
NodeType: StatelessNodeType<"update", UpdateNodeProperties> = createNodeType<'update',UpdateNodeProperties>('update', {shape: {target: graphTypes.nodeDefinition,updater: graphTypes.nodeDefinition,},operations: {evaluate: {cacheable: false,getDependencies({ target, updater }: UpdateNodeProperties): [NodeDependency] {return [{target: call(updater, [target]),},];},run(node: UpdateNode, operation: never, [newValueNode]: [GraphNode]): NodeDefinition {return set(node.definition.properties.target, newValueNode.definition);},},},})
Const UpperCaseNodeType
Upper
CaseNodeType: StatelessNodeType<"upper-case", UpperCaseNodeProperties> = createNodeType<'upper-case', UpperCaseNodeProperties>('upper-case', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: UpperCaseNodeProperties): Array<NodeDependency> {return [{target: subject,until: untilStringValueNode(UpperCaseNodeType, 'subject'),},];},run(node: UpperCaseNode, options: never, [subject]: [ValueNode<string>]): NodeDefinition {return value(subject.definition.properties.value.toUpperCase());},},},})
Const ValueNodeType
Value
NodeType: StaticNodeType<"value", ValueNodeProperties<any>> = createNodeType<'value',ValueNodeProperties<any>>('value', {shape: {value: types.optional(types.saveHash(types.any)),},operations: {length: {run(node: ValueNode<any>): NodeDefinition {const { value: currentValue } = node.definition.properties;if (typeof currentValue === 'string') return value(currentValue.length);if (Array.isArray(currentValue)) return value(currentValue.length);return error('This value node does not support the length operation.');},},},})
Const VariableNodeType
Variable
NodeType: StatefulNodeType<"variable", VariableNodeProperties, VariableNodeState, VariableNodeData> = createNodeType<'variable', VariableNodeProperties, VariableNodeState, VariableNodeData>('variable',{state: {currentValue: types.optional(graphTypes.nodeDefinition),setResults: types.objectOf(graphTypes.nodeDefinition),},shape: {initialValue: graphTypes.nodeDefinition,validator: types.saveHash(types.matcher),},getInitialState(): VariableNodeState {return {currentValue: undefined,setResults: {},};},operations: {evaluate: {run(node: VariableNode,operation: never,dependencies: Array<never>,context: Array<never>,state: VariableNodeState,): NodeDefinition {const { currentValue } = state;return currentValue || node.definition.properties.initialValue;},},set: {run(node: VariableNode,operation: SetOperation,dependencies: never,context: never,state: VariableNodeState,): NodeDefinition {return state.setResults[operation.id];},onSubscribe(this: NodeExecutionContext<VariableNodeState, VariableNodeData>,node: VariableNode,operation: SetOperation,): void {const { currentValue: previousValue } = this.getState();const { validator } = node.definition.properties;const { value } = operation.properties;if (!previousValue) {this.retain();this.setData({disposeResetVariableListener: node.scope.events.listen((event) => {if (event.type !== EVENT_RESET_VARIABLE) return;resetVariableNode(this);}),});}// Check if the value is validif (isValueNodeDefinition(value) ? validator(valueOf(value)) : validator(value)) {// All is good in variable worldthis.setState((state) => ({...state,currentValue: value,setResults: {...state.setResults,[operation.id]: ok(),},}));} else {// Whoops, wrong value type!this.setState((state) => ({...state,setResults: {...state.setResults,[operation.id]: error(getInvalidTypeError('Could not set value of the variable node: value has an incorrect type.',{expected: `Value matched by ${getType(validator)}`,received: value,},),),},}));}},onUnsubscribe(this: NodeExecutionContext<VariableNodeState, VariableNodeData>,node: VariableNode,operation: SetOperation,): void {this.setState((state) => ({...state,setResults: omit(state.setResults, operation.id),}));},},reset: {run(node: VariableNode,options: never,dependencies: Array<never>,context: Array<never>,state: VariableNodeState,): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<VariableNodeState, VariableNodeData>,node: VariableNode,): void {resetVariableNode(this);},},},},)
Const WILDCARD_OPERATION
WILDCARD_OPERATION: "$$WILDCARD_OPERATION" = "$$WILDCARD_OPERATION"
Const WhenNodeType
When
NodeType: StaticNodeType<"when", WhenNodeProperties> = createNodeType<'when',WhenNodeProperties>('when', {shape: {pattern: graphTypes.nodeDefinition,value: graphTypes.nodeDefinition,},})
Const WithContextNodeType
With
ContextNodeType: StatelessNodeType<"withContext", WithContextNodeProperties> = createNodeType<'withContext', WithContextNodeProperties>('withContext', {shape: {values: types.objectOf(types.oneOfType<NodeDefinition | GraphNode>([graphTypes.nodeDefinition,graphTypes.graphNode,]),),target: graphTypes.nodeDefinition,},operations: {evaluate: {run(node: WithContextNode): GraphNode {const { target, values } = node.definition.properties;const boundContextValues = fromPairs([...Object.getOwnPropertySymbols(values), ...Object.keys(values)].map((contextKey): [string | symbol, GraphNode] => {// TODO: Remove the `as any` cast once https://github.com/Microsoft/TypeScript/issues/1863 is resolvedconst value = values[contextKey as any];return [contextKey, isGraphNode(value) ? value : withScopeFrom(node, value)];},),);const childContext = createContext(node.context, boundContextValues);return createGraphNode(node.scope, childContext, target);},},},})
Const WithScopeNodeType
With
ScopeNodeType: StatelessNodeType<"withScope", WithScopeNodeProperties> = createNodeType<'withScope', WithScopeNodeProperties>('withScope', {shape: {target: types.oneOfType<NodeDefinition | GraphNode>([graphTypes.nodeDefinition,graphTypes.graphNode,]),expression: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target, expression }: WithScopeNodeProperties): [NodeDependency] {return [{ target }];},run(node: WithScopeNode, options: never, [subjectNode]: [GraphNode]): GraphNode {const { expression } = node.definition.properties;return withScopeFrom(subjectNode, expression);},},},})
Const WithTransformsNodeType
With
TransformsNodeType: StaticNodeType<"withTransforms", WithTransformsNodeProperties> = createNodeType<'withTransforms', WithTransformsNodeProperties>('withTransforms', {shape: {transforms: types.arrayOf(graphTypes.nodeDefinition),fields: graphTypes.nodeDefinition,},})
Const XhrMiddlewareNodeType
Xhr
MiddlewareNodeType: StatelessNodeType<"xhr-middleware", XhrMiddlewareNodeProperties> = createNodeType('xhr-middleware', {shape: {headers: types.optional(graphTypes.nodeDefinition),log: types.bool,nodeTypes: types.saveHash(types.any),numberOfRetries: types.number,operationTypes: types.saveHash(types.any),requestTimeout: types.number,retryDelay: types.number,url: types.string,withCredentials: types.bool,},operations: {request: {run(node: XhrMiddlewareNode, operation: RequestOperation): NodeDefinition | GraphNode {const { query } = operation.properties;const options = node.definition.properties;const processRequest = (headersNode?: NodeDefinition): GraphNode => {if (options.log) {console.log(`Request [${operation.id}] headers:`, getType(headersNode));}const headersObject = {Accept: 'application/json, text/plain, */*','Content-Type': 'application/json',...(getCustomHeaders(headersNode) || {}),};const requestStream = doHttpRequest({body: JSON.stringify(attachMetadata(sanitize(query))),headers: headersObject,numberOfRetries: options.numberOfRetries,retryDelay: options.retryDelay,requestTimeout: options.requestTimeout,url: options.url,withCredentials: options.withCredentials,});const responseStream = map((response) => deserializeResponse(options.nodeTypes, options.operationTypes, response),requestStream,);return withScopeFrom(node, fromStream(responseStream));};if (!options.headers) return processRequest();return resolve([{ target: options.headers, once: true }], ([resolvedHeaders]) =>processRequest(resolvedHeaders.definition),);},},},})
Const any
any
: Matcher<any, never> = createMatcher<any, never>('any', (value: any) => true)
Const array
array
: HashFunction<any[]> = unique as HashFunction<Array<any>>
Const array
array
: Matcher<any[], never> = createMatcher<Array<any>, never>('array', Array.isArray)
Const arrayOf
array
Of: ValueHasherFactory<Object[], Matcher<Object, any>> = (<T>() =>createHasherFactory('arrayOf',(matcher: Matcher<T, any>): HashFunction<Array<T>> => {const itemHasher = type(matcher);return (value: Array<T>): string => {let hash = 't(';// tslint:disable-next-line:no-increment-decrementfor (let i = 0; i < value.length; i++) {hash += `${itemHasher(value[i])}|`;}return `${hash})`;};},))()
Const bool
bool
: Matcher<boolean, never> = createMatcher<boolean, never>('bool',(value: any) => typeof value === 'boolean',)
Let cachedActionId
cachedActionId: number = 0
Const context
context
: HashFunction<Context> = hash.registerTypeHasher(graphTypes.context,(value: Context) => value.id,)
Const date
date
: Matcher<Date, never> = createMatcher<Date, never>('date', (value: any) =>Boolean(value && value.constructor === Date),)
Const empty
empty
: Matcher<undefined, never> = createMatcher<undefined, never>('empty',(value: any) => typeof value === 'undefined',)
Const es6TemplateStrings
es6TemplateStrings: any = require('es6-template-strings')
Const event
event
: HashFunction<MusterEvent> = hash.registerTypeHasher(graphTypes.event,(value: MusterEvent): string => `${hash.string(value.type)}:${hash.any(value.payload)}`,)
Const func
func
: Matcher<Function, never> = createMatcher<Function, never>('func',(value: any) => typeof value === 'function',)
Const func
func
: HashFunction<Function> = unique as HashFunction<Function>
Const global
global: Window & object
Const graphAction
graph
Action: HashFunction<GraphAction> = hash.registerTypeHasher(graphTypes.graphAction,(value: GraphAction): string => value.id,)
Const graphDeprecationWarning
graphDeprecationWarning: function = deprecated({old: 'graph',new: 'toNode',})
Const graphHash
graphHash: "/Users/wragdav/db-projects/muster-gh-staging/packages/muster/src/utils/graph-hash" = _graphHash
Const graphNode
graph
Node: HashFunction<GraphNode> = hash.registerTypeHasher(graphTypes.graphNode,(value: GraphNode): string => value.id,)
Const graphOperation
graph
Operation: HashFunction<GraphOperation> = hash.registerTypeHasher(graphTypes.graphOperation,(value: GraphOperation): string => value.id,)
Const graphTypes
graphTypes: "/Users/wragdav/db-projects/muster-gh-staging/packages/muster/src/utils/graph-types" = _graphTypes
Const hash
hash: "/Users/wragdav/db-projects/muster-gh-staging/packages/muster/src/utils/hash" = _hash
Const hashContextValues
hash
ContextValues: HashFunction<object> = hashObjectOf(graphTypes.graphNode)
Const ignore
ignore
: Matcher<any, never> = createMatcher<any, never>('ignore', (value: any) => true)
Const instance
instance
: HashFunction<object> = unique as HashFunction<object>
Const instanceOf
instance
Of: HashFunction<object> = unique as HashFunction<object>
Const integer
integer
: Matcher<number, never> = createMatcher<number, never>('integer', Number.isInteger)
Const isPlainObject
isPlainObject: any = require('is-plain-object')
Const matcher
matcher
: Matcher<Matcher<any, any>, never> = createMatcher<Matcher<any, any>, never>('matcher', (value: any) =>isMatcher(value),)
Const migrationsInOrder
migrations
InOrder: Migration[] = [from50to51, from51to60, from60to66] as Array<Migration>
Const migrator
migrator
: Migrator<NodeBefore, NodeAfter> = createMigrator<NodeBefore, NodeAfter>({[DEFAULT]: {downgrade(node, traverse): NodeBefore {return {$type: node.$type,data: traverse(node.data),};},upgrade(node, traverse): NodeAfter {return {$type: node.$type,data: traverse(node.data),};},},'inject-dependencies': {downgrade(node, traverse): NodeBefore {return {$type: 'partial',data: traverse(node.data),};},},items: {upgrade(node, traverse): NodeAfter {if (Array.isArray(node.data.transforms) && node.data.transforms.length > 0) {return {$type: 'withTransforms',data: {transforms: traverse(node.data.transforms),fields: {$type: 'entries',data: {children: traverse(node.data.children),},},},};}return {$type: 'entries',data: {children: traverse(node.data.children),},};},},entries: {downgrade(node, traverse): NodeBefore {return {$type: 'items',data: {transforms: undefined,children: traverse(node.data.children),},};},},withTransforms: {downgrade(node, traverse): NodeBefore {return {$type: 'items',data: {transforms: traverse(node.data.transforms),children: traverse((node.data.fields as NodeAfter).data.children),},};},},partial: {upgrade(node, traverse): NodeAfter {return {$type: 'inject-dependencies',data: traverse(node.data),};},},takeFirst: {upgrade(node, traverse): NodeAfter {return {$type: 'firstItem',data: traverse(node.data),};},},firstItem: {downgrade(node, traverse): NodeBefore {return {$type: 'takeFirst',data: traverse(node.data),};},upgrade(node, traverse): NodeAfter {return {$type: 'head',data: traverse(node.data),};},},head: {downgrade(node, traverse): NodeBefore {return {$type: 'firstItem',data: traverse(node.data),};},},takeLast: {upgrade(node, traverse): NodeAfter {return {$type: 'lastItem',data: traverse(node.data),};},},lastItem: {downgrade(node, traverse): NodeBefore {return {$type: 'takeLast',data: traverse(node.data),};},},takeNth: {upgrade(node, traverse): NodeAfter {return {$type: 'nthItem',data: traverse(node.data),};},},nthItem: {downgrade(node, traverse): NodeBefore {return {$type: 'takeNth',data: traverse(node.data),};},},sortOrder: {downgrade(node, traverse): NodeBefore {const { iteratee, descending } = traverse(node.data);return {$type: 'sortOrder',data: {descending,iteratee: {$type: 'fn',data: {argIds: [...iteratee.data.argIds, '$$dummyItemIndex'],body: iteratee.data.body,},},},};},upgrade(node, traverse): NodeAfter {const { iteratee, descending } = traverse(node.data);const [itemArg, itemIndexArg] = iteratee.data.argIds;return {$type: 'sortOrder',data: {descending,iteratee: {$type: 'fn',data: {argIds: [itemArg],body: replaceContextWithValue(iteratee.data.body, itemIndexArg, 0),hasNamedArgs: false,},},},};},},collection: {upgrade(node, traverse): NodeAfter {const { source, transforms } = traverse(node.data);if (transforms.length === 0) return source;return {$type: 'applyTransforms',data: {target: source,transforms,},};},},applyTransforms: {downgrade(node, traverse): NodeBefore {const { target, transforms } = traverse(node.data);return {$type: 'collection',data: {source: target,transforms,},};},},legacyQuery: {downgrade(node, traverse): NodeBefore {return {$type: 'query',data: traverse(node.data),};},},query: {upgrade(node, traverse): NodeAfter {return {$type: 'legacyQuery',data: traverse(node.data),};},},fn: {upgrade(node, traverse): NodeAfter {return {$type: 'fn',data: {argIds: traverse(node.data.argIds),body: traverse(node.data.body),hasNamedArgs: false,},};},downgrade(node, traverse): NodeBefore {return {$type: 'fn',data: {argIds: traverse(node.data.argIds),body: traverse(node.data.body),},};},},})
Const migrator
migrator
: Migrator<NodeBefore, NodeAfter> = createMigrator<NodeBefore, NodeAfter>({[DEFAULT]: {downgrade(node, traverse): NodeBefore {return {$type: node.$type,...mapValues(node.data, traverse),};},upgrade(node, traverse): NodeAfter {const keys = Object.keys(node).filter((k) => k !== '$type');return {$type: node.$type,data: keys.reduce((data: any, key: string) => {data[key] = traverse(node[key]);return data;}, {}),};},},apply: {upgrade(node, traverse): NodeAfter {return {$type: 'apply',data: {args: traverse(node.args),target: traverse(node.fn),},};},downgrade(node, traverse): NodeBefore {return {$type: 'apply',args: traverse(node.data.args),fn: traverse(node.data.target),};},},array: {upgrade(node, traverse): NodeAfter {return {$type: 'array',data: {items: traverse(node.nodes),},};},downgrade(node, traverse): NodeBefore {return {$type: 'array',nodes: traverse(node.data.items),};},},branch: {upgrade(node, traverse): NodeAfter {return {$type: 'tree',data: {branches: (node.branches || []).map((branch: any) => ({match: branch.match,node: traverse(branch.node),param: branch.name,})),},};},},context: {upgrade(node, traverse): NodeAfter {return {$type: 'context',data: {name: node.identifier,},};},downgrade(node, traverse): NodeBefore {return {$type: 'context',identifier: node.data.name,};},},decrement: {downgrade(node, traverse): NodeBefore {return {$type: 'subtract',operands: [traverse(node.data.operand), { $type: 'value', value: 1 }],};},},get: {upgrade(node, traverse): NodeAfter {// TODO: Handle the item placeholder (first, last, nth, ...)const key =node.childGetter.$type === 'key'? traverse(node.childGetter.key): traverse(node.childGetter); // TODO: Is this right?return {$type: 'get',data: {subject: traverse(node.subject),key,},};},downgrade(node, traverse): NodeBefore {// TODO: Handle the item placeholder (first, last, nth, ...)return {$type: 'get',childGetter: {$type: 'key',key: traverse(node.data.key),},subject: traverse(node.data.subject),};},},increment: {downgrade(node, traverse): NodeBefore {return {$type: 'add',operands: [traverse(node.data.operand), { $type: 'value', value: 1 }],};},},match: {upgrade(node, traverse): NodeAfter {return {$type: 'match-pattern',data: {regex: traverse(node.regex),subject: traverse(node.subject),},};},},'match-pattern': {downgrade(node, traverse): NodeBefore {return {$type: 'match',regex: traverse(node.data.regex),subject: traverse(node.data.subject),};},},multiple: {upgrade(node, traverse): NodeAfter {return {$type: 'parallel',data: {operations: (node.nodes || []).map(traverse),},};},},parallel: {downgrade(node, traverse): NodeBefore {return {$type: 'parallel',nodes: traverse(node.data.operations),};},upgrade(node, traverse): NodeAfter {return {$type: 'parallel',data: {operations: traverse(node.nodes),},};},},param: {upgrade(node, traverse): NodeAfter {return {$type: 'param',data: {name: node.id,},};},downgrade(node, traverse): NodeBefore {return {$type: 'param',id: node.data.name,};},},query: {upgrade(node, traverse): NodeAfter {return {$type: 'query',data: {root: traverse(node.root),keys: traverse(node.getters),},};},downgrade(node, traverse): NodeBefore {return {$type: 'query',root: traverse(node.data.root),getters: traverse(node.data.keys),};},},ref: {upgrade(node, traverse): NodeAfter {// TODO: Handle the item placeholder (first, last, nth, ...)const toNestedGet = (target: any, path: Array<any>): any => {const [key, ...remaining] = path;const get = {$type: 'get',data: {subject: target,key: traverse(key),},};if (remaining.length === 0) return get;return toNestedGet(get, remaining);};return toNestedGet(traverse(node.root), node.path);},},series: {upgrade(node, traverse): NodeAfter {return {$type: 'series',data: {operations: traverse(node.nodes),},};},downgrade(node, traverse): NodeBefore {return {$type: 'series',nodes: traverse(node.data.operations),};},},'sort-order': {upgrade(node, traverse): NodeAfter {return {$type: 'sortOrder',data: {descending: node.descending,iteratee: traverse(node.iteratee),},};},},sortOrder: {downgrade(node, traverse): NodeBefore {return {$type: 'sort-order',descending: node.data.descending,iteratee: traverse(node.data.iteratee),};},},'take-first': {upgrade(node, traverse): NodeAfter {return { $type: 'takeFirst', data: {} };},},takeFirst: {downgrade(node, traverse): NodeBefore {return { $type: 'take-first' };},},'take-last': {upgrade(node, traverse): NodeAfter {return { $type: 'takeLast', data: {} };},},takeLast: {downgrade(node, traverse): NodeBefore {return { $type: 'take-last' };},},'take-nth': {upgrade(node, traverse): NodeAfter {return {$type: 'takeNth',data: {index: traverse(node.index),},};},},takeNth: {downgrade(node, traverse): NodeBefore {return {$type: 'take-nth',index: traverse(node.data.index),};},},tree: {downgrade(node, traverse): NodeBefore {const branches = node.data.branches || [];const isSimpleTree = branches.every((branch: any) => !(branch.match || '').startsWith('$$match:'),);if (isSimpleTree) {return {$type: 'tree',branches: branches.reduce((tree: any, branch: any) => {if (branch.match) {tree[branch.match] = traverse(branch.node);}return tree;}, {}),};}return {$type: 'tree',branches: (node.data.branches || []).map((branch: any) => ({match: branch.match,name: branch.param,node: traverse(branch.node),})),};},upgrade(node, traverse): NodeAfter {return {$type: 'tree',data: {branches: toPairs(node.branches).map(([name, node]) => ({match: name,node: traverse(node),})),},};},},'with-context': {upgrade(node, traverse): NodeAfter {return {$type: 'withContext',data: {target: traverse(node.node),values: mapValues(node.context),},};},},withContext: {downgrade(node, traverse): NodeBefore {return {$type: 'with-context',node: traverse(node.data.target),context: mapValues(traverse),};},},})
Const migrator
migrator
: Migrator<NodeBefore, NodeAfter> = createMigrator<NodeBefore, NodeAfter>({[DEFAULT]: {downgrade(node, traverse): NodeBefore {return {$type: node.$type,data: traverse(node.data),};},upgrade(node, traverse): NodeAfter {return {$type: node.$type,data: traverse(node.data),};},},query: {downgrade(node, traverse): NodeBefore {return {$type: node.$type,data: {keys: traverse(node.data.keys),root: traverse(node.data.root),},};},upgrade(node, traverse): NodeAfter {return {$type: node.$type,data: {keys: traverse(node.data.keys),options: {omitNils: false,},root: traverse(node.data.root),},};},},'query-set': {downgrade(node, traverse): NodeBefore {return {$type: node.$type,data: {children: traverse(node.data.children),options: {bubbleErrorsToTop: (node.data.options as any).bubbleErrorsToTop,},root: traverse(node.data.root),},};},upgrade(node, traverse): NodeAfter {return {$type: node.$type,data: {children: traverse(node.data.children),options: {bubbleErrorsToTop: (node.data.options as any).bubbleErrorsToTop,omitNils: false,},root: traverse(node.data.root),},};},},})
Const musterVersion
musterVersion: any = require('@dws/muster-version')
Let nextPopId
nextPopId: number = 1
Let nextShiftId
nextShiftId: number = 1
Const nil
nil
: Matcher<null, never> = createMatcher<null, never>('nil', (value: any) => value === null)
Const nodeDefinition
node
Definition: HashFunction<NodeDefinition> = hash.registerTypeHasher(graphTypes.nodeDefinition,(value: NodeDefinition): string => value.id,)
Const nodeDependency
node
Dependency: Matcher<NodeDependency> = types.shape({allowErrors: types.optional(types.bool),allowPending: types.optional(types.bool),acceptNil: types.optional(types.bool),until: types.optional(types.shape({predicate: types.func,errorMessage: types.optional(types.func),}),),once: types.optional(types.bool),invalidate: types.optional(types.bool),target: types.oneOfType([nodeDefinition, graphNode]),})
Const nodeDependencyShapeHasher
Const nodeType
node
Type: HashFunction<NodeType> = hash.registerTypeHasher(graphTypes.nodeType,(value: NodeType) => value.name,)
Const nodeTypes
nodeTypes: Dictionary<object> = mapValues(getMusterNodeTypesMap(), (nodeType) => ({operations: Object.keys((nodeType as DynamicNodeType).operations || {}),}))
Const number
number
: Matcher<number, never> = createMatcher<number, never>('number',(value: any) => typeof value === 'number',)
Const object
object
: Matcher<object, never> = createMatcher<object, never>('object', (value: any) => isPlainObject(value))
Const object
object
: HashFunction<object> = unique as HashFunction<object>
Const objectOf
object
Of: ValueHasherFactory<object, Matcher<Object, any>> = (<T>() =>createHasherFactory('objectOf',(matcher: Matcher<T, any>,): HashFunction<{[key: string]: T;}> => {const valueHasher = type(matcher);return (value: { [key: string]: T }): string => {let hash = 'm(';const symbolKeys = Object.getOwnPropertySymbols(value);// tslint:disable-next-line:no-increment-decrementfor (let i = 0; i < symbolKeys.length; i++) {const key = symbolKeys[i];// TODO: Remove the `as any` cast once https://github.com/Microsoft/TypeScript/issues/1863 is resolvedhash += `${symbol(key)}=${valueHasher(value[key as any])}`;}const objectKeys = Object.keys(value).filter((key) => value.hasOwnProperty(key));// tslint:disable-next-line:no-increment-decrementfor (let i = 0; i < objectKeys.length; i++) {const key = objectKeys[i];hash += `${string(key)}=${valueHasher(value[key])}|`;}return `${hash})`;};},))()
Const objectToTreeDeprecationWarning
objectToTreeDeprecationWarning: function = deprecated({old: 'objectToTree',new: 'toNode',})
Const oneOf
one
Of: ValueHasherFactory<Object, Object[]> = (<T>() =>createHasherFactory('oneOf',(values: Array<T>): HashFunction<T> => {return (value: T): string => `p${values.indexOf(value)}`;},))()
Const oneOfType
one
OfType: ValueHasherFactory<Object, Matcher<Object, any>[]> = (<T>() =>createHasherFactory('oneOfType',(matchers: Array<Matcher<T, any>>): HashFunction<T> => {const matcherHasherPairs = matchers.map((matcher) => [matcher, type(matcher)] as [Matcher<T>, HashFunction<T>],);return (value: T): string => {// tslint:disable-next-line:no-increment-decrementfor (let index = 0; index < matcherHasherPairs.length; index++) {const [matcher, hasher] = matcherHasherPairs[index];if (matcher(value)) {return `${index}:${hasher(value)}`;}}return 'u';};},))()
Const operation
operation: operation & object = Object.assign(// tslint:disable-next-line:ter-prefer-arrow-callbackfunction operation(definition: MusterOperation): MusterOperation {return definition;},{only: (definition: MusterOperation): MusterOperation => {return {only: true,...operation(definition),};},skip: (definition: MusterOperation): MusterOperation => {return {skip: true,...operation(definition),};},},)
Const operationType
operation
Type: HashFunction<OperationType> = hash.registerTypeHasher(graphTypes.operationType,(value: OperationType) => value.name,)
Const optional
optional
: ValueHasherFactory<undefined | Object, Matcher<Object, any>> = (<T>() =>createHasherFactory('optional',(matcher: Matcher<T, any>): HashFunction<T | undefined> => {const typeHasher = type(matcher);return (value: T | undefined): string => {if (typeof value === 'undefined' || value === null) return 'u';return typeHasher(value);};},))()
Const proxiedNode
proxied
Node: HashFunction<ProxiedNode> = hash.registerTypeHasher(graphTypes.proxiedNode,(value: ProxiedNode): string => `P(${getProxiedNodeValue(value).id})`,)
Const registerJestMatchers
registerJestMatchers: (Anonymous function) = once(() => {const jestExpect = global.expect;global.expect = Object.assign((received: any) => {const matchers = jestExpect(received);matchers.toEqual = decorateMatcher(matchers.toEqual);matchers.toHaveBeenCalledWith = decorateMatcher(matchers.toHaveBeenCalledWith);matchers.toHaveBeenLastCalledWith = decorateMatcher(matchers.toHaveBeenLastCalledWith);return matchers;}, jestExpect);setUnitTestMatcher(isJestAsymetricMatcher);})
Const saveHash
save
Hash: ValueHasherFactory<Object, Matcher<Object, any>> = (<T>() =>createHasherFactory('saveHash',(matcher: Matcher<T, any>): HashFunction<T> => {const typeHasher = type(matcher);return (value: T): string => {if ((value as any)['$$hash']) return (value as any)['$$hash'];const hash = typeHasher(value);if ((typeof value === 'object' && value !== null) || typeof value === 'function') {Object.defineProperty(value, '$$hash', {value: hash,enumerable: false,configurable: true,});}return hash;};},))()
Const scope
scope
: HashFunction<Scope> = hash.registerTypeHasher(graphTypes.scope,(value: Scope) => value.id,)
Const shape
shape
: ValueHasherFactory<Object, object> = (<T extends { [key in keyof T]: T[key] }>() =>createHasherFactory('shape',(fields: ShapeFields<T>): HashFunction<T> => {const propHashers = Object.keys(fields).map((key) => ({key,hash: type((fields as any)[key]),}));return (value: T): string => {let hash = 's(';// tslint:disable-next-line:no-increment-decrementfor (let i = 0; i < propHashers.length; i++) {const propHasher = propHashers[i];hash += `${propHasher.hash((value as any)[propHasher.key])}|`;}return `${hash})`;};},))()
Const showCollectionDeprecationWarning
showCollectionDeprecationWarning: function = deprecated({old: 'collection',new: 'applyTransforms',})
Const showGetItemsDeprecationWarning
showGetItemsDeprecationWarning: function = deprecated({old: 'getItems',new: 'applyTransforms',})
Const showRefArrayDeprecationWarning
showRefArrayDeprecationWarning: function = deprecated({ old: 'ref([...])', new: 'ref(...)' })
Const showRelativeArrayDeprecationWarning
showRelativeArrayDeprecationWarning: function = deprecated({old: 'relative([...])',new: 'relative(...)',})
Const showStrlenDeprecationWarning
showStrlenDeprecationWarning: function = deprecated({old: 'strlen',new: 'length',})
Const stream
stream: "/Users/wragdav/db-projects/muster-gh-staging/packages/muster/src/utils/stream" = _stream
Const string
string
: Matcher<string, never> = createMatcher<string, never>('string',(value: any) => typeof value === 'string',)
Const stringHash
stringHash: any = require('string-hash')
Const symbol
symbol
: HashFunction<symbol> = ((): HashFunction<symbol> => {const symbolToIdMap = new Map<symbol, string>();return (value: symbol) => {const symbolId = symbolToIdMap.get(value);if (symbolId) return symbolId;const newSymbolId = `$${symbolToIdMap.size}`;symbolToIdMap.set(value, newSymbolId);return newSymbolId;};})()
Const symbol
symbol
: Matcher<symbol, never> = createMatcher<symbol, never>('symbol',(value: any) => typeof value === 'symbol',)
Const treeToObjectDeprecationWarning
treeToObjectDeprecationWarning: function = deprecated({old: 'treeToObject',new: 'valueOf',})
Const types
types: "/Users/wragdav/db-projects/muster-gh-staging/packages/muster/src/utils/types" = _types
Const unique
unique
: HashFunction<Object> = (<T>(): HashFunction<T> => {let uid = 0;// tslint:disable-next-line:no-increment-decrementreturn (value: T): string => `*${++uid}`;})()
Const untilBooleanValueNodeItem
Const untilBooleanValuePredicate
Const untilIntegerValueIndex
Const untilIsPositiveIntegerValueNode
Const untilPositiveIntegerLength
Const untilPositiveIntegerOffset
Const untilPositiveIntegerOffset
Const untilPositiveNumItemsNode
Const untilPositiveValueIndex
Const untilValidSeparator
Const version
version: any = require('@dws/muster-version')
Const xhr
xhr: any = require('xhr')
Object literals
Const DEFAULT_QUERY_OPTIONS
DEFAULT_QUERY_OPTIONS: object
omitNils
omitNils: false = false
Const DEFAULT_QUERY_SET_OPTIONS
DEFAULT_QUERY_SET_OPTIONS: object
bubbleErrorsToTop
bubbleErrorsToTop: false = false
omitNils
omitNils: false = false
Const RESOLVE_NODE_SHAPE
RESOLVE_NODE_SHAPE: object
combine
combine
: Matcher<undefined | Function, Matcher<Function, any>> = types.saveHash(types.func)
dependencies
dependencies
: Matcher<(NodeDependency | GraphAction<string, object, any, object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>, StaticNodeType<string, object, object>, StatelessNodeType<string, object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>> | StatefulNodeType<string, object, any, object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>>>)[], Matcher<NodeDependency | GraphAction<string, object, any, object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>, StaticNodeType<string, object, object>, StatelessNodeType<string, object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>> | StatefulNodeType<string, object, any, object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>>>, any>> = types.arrayOf(types.oneOfType<NodeDependency | GraphAction>([types.shape({target: types.oneOfType<NodeDefinition | GraphNode>([graphTypes.graphNode,graphTypes.nodeDefinition,]),allowErrors: types.optional(types.bool),allowPending: types.optional(types.bool),acceptNil: types.optional(types.bool),once: types.optional(types.bool),until: types.optional(types.shape({predicate: types.saveHash(types.func),errorMessage: types.optional(types.oneOfType<string | Function>([types.string, types.saveHash(types.func)]),),}),),}),graphTypes.graphAction,]),)
Const ResolveNodeType
ResolveNodeType: object
__computed
__computed: true = true
deserialize
deserialize: false = false as false
name
name: "resolve" = "resolve"
serialize
serialize: false = false as false
shape
shape
: Matcher<Object, object> = types.shape(RESOLVE_NODE_SHAPE)
is
-
Parameters
Returns boolean
operations
operations: object
evaluate
evaluate: object
cacheable
cacheable: true = true
getContextDependencies
- getContextDependencies(): Array<never>
run
-
Parameters
-
-
options: never
-
dependencies: Array<GraphNode>
Const TRAVERSE_NODE_SHAPE
TRAVERSE_NODE_SHAPE: object
root
root
: Matcher<NodeDefinition<any, any, any, object, any, StaticNodeType<any, any, any> | StatelessNodeType<any, any, any, string, GraphOperation<string, object, object, OperationType<string, object, object>>> | StatefulNodeType<any, any, any, object, any, string, GraphOperation<string, object, object, OperationType<string, object, object>>>>, Matcher<NodeDefinition<any, any, any, object, any, StaticNodeType<any, any, any> | StatelessNodeType<any, any, any, string, GraphOperation<string, object, object, OperationType<string, object, object>>> | StatefulNodeType<any, any, any, object, any, string, GraphOperation<string, object, object, OperationType<string, object, object>>>>, any>[]> = types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])
Const TraverseNodeType
TraverseNodeType: object
__computed
__computed: true = true
deserialize
deserialize: false = false as false
hash
hash
: HashFunction<Object> = hash.shape(TRAVERSE_NODE_SHAPE)
name
name: "traverse" = "traverse"
serialize
serialize: false = false as false
shape
shape
: Matcher<Object, object> = types.shape(TRAVERSE_NODE_SHAPE)
is
-
Parameters
Returns boolean
operations
operations: object
evaluate
evaluate: object
cacheable
cacheable: true = true
getContextDependencies
getContextDependencies: function = constant([])
Const base64Encoder
base64Encoder: object
decode
- decode(value: string): any
encode
- encode(value: any): string
-
Parameters
Returns string
Const identityEncoder
identityEncoder: object
decode
decode: identity = identity
encode
encode: identity = identity
Const isValidReducerStepResult
isValidReducerStepResult: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const jsonEncoder
jsonEncoder: object
decode
decode: parse = JSON.parse
encode
encode: stringify = JSON.stringify
Const shallow
shallow: object
Const untilConditionIsValueNode
untilConditionIsValueNode: object
predicate
predicate: function = ValueNodeType.is
Type declaration
-
-
Parameters
Returns boolean
errorMessage
-
Parameters
Returns string
Const untilDataNode
untilDataNode: object
errorMessage
-
Parameters
Returns string
Const untilInputIsValueNode
untilInputIsValueNode: object
predicate
predicate: function = ValueNodeType.is
Type declaration
-
-
Parameters
Returns boolean
errorMessage
-
Parameters
Returns string
Const untilIsArrayNodeOrPendingNode
untilIsArrayNodeOrPendingNode: object
errorMessage
-
Parameters
Returns string
Const untilIsCollectionOrFullyResolvedNode
untilIsCollectionOrFullyResolvedNode: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilIsContainerOrFullyResolvedNode
untilIsContainerOrFullyResolvedNode: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilIsDataNode
untilIsDataNode: object
errorMessage
-
Parameters
Returns string
Const untilIsFieldsNodeOrCollectionFieldsNode
untilIsFieldsNodeOrCollectionFieldsNode: object
errorMessage
-
Parameters
Returns string
Const untilIsFullyResolvedNode
untilIsFullyResolvedNode: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilIsFullyResolvedValueNode
untilIsFullyResolvedValueNode: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilIsSortOrderNode
untilIsSortOrderNode: object
predicate
predicate: function = SortOrderNodeType.is
Type declaration
-
-
Parameters
Returns boolean
errorMessage
-
Parameters
Returns string
Const untilIsValidIteratorResult
untilIsValidIteratorResult: object
errorMessage
-
Parameters
Returns string
Const untilIsValidSortValue
untilIsValidSortValue: object
errorMessage
-
Parameters
Returns string
Const untilIsValueNode
untilIsValueNode: object
predicate
predicate: function = ValueNodeType.is
Type declaration
-
-
Parameters
Returns boolean
errorMessage
-
Parameters
Returns string
Const untilIsValueNodeOrKeyNode
untilIsValueNodeOrKeyNode: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilItemWithId
untilItemWithId: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilNodeSupportedByGet
untilNodeSupportedByGet: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilPatternIsValueNodeOrCallableNode
untilPatternIsValueNodeOrCallableNode: object
errorMessage
-
Parameters
Returns string
Const untilPlaceholderOrItems
untilPlaceholderOrItems: object
predicate
-
Parameters
Returns boolean
Const untilSupportsAddItemAtOperation
untilSupportsAddItemAtOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsCallOperation
untilSupportsCallOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsCallOperation
untilSupportsCallOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsCallOperation
untilSupportsCallOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsClearOperation
untilSupportsClearOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsGetChildOperation
untilSupportsGetChildOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsGetItemOperation
untilSupportsGetItemOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsGetItemOperation
untilSupportsGetItemOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsGetItemsOperation
untilSupportsGetItemsOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsGetItemsOperation
untilSupportsGetItemsOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsIsUpdatingOperationOrStaticNode
untilSupportsIsUpdatingOperationOrStaticNode: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilSupportsIterateOperation
untilSupportsIterateOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsIterateOperation
untilSupportsIterateOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsPopOperation
untilSupportsPopOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsPushOperation
untilSupportsPushOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsRemoveItemAtOperation
untilSupportsRemoveItemAtOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsRemoveItemOperation
untilSupportsRemoveItemOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsRemoveItemsOperation
untilSupportsRemoveItemsOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsSetOperation
untilSupportsSetOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsShiftOperation
untilSupportsShiftOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsStepOperation
untilSupportsStepOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsTransformItemsOperation
untilSupportsTransformItemsOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsUnshiftOperation
untilSupportsUnshiftOperation: object
errorMessage
-
Parameters
Returns string
Const untilValidGetItemsResult
untilValidGetItemsResult: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilValidGetItemsResult
untilValidGetItemsResult: object
predicate
-
Parameters
Returns boolean
Const untilValidInitializer
untilValidInitializer: object
predicate
predicate: function = ValueNodeType.is
Type declaration
-
-
Parameters
Returns boolean
errorMessage
-
Parameters
Returns string
Const untilValidJoinOperand
untilValidJoinOperand: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilValidPlaceholderResult
untilValidPlaceholderResult: object
predicate
-
Parameters
Returns boolean
Const untilValidReducerStep
untilValidReducerStep: object
predicate
predicate: function = ValueNodeType.is
Type declaration
-
-
Parameters
Returns boolean
errorMessage
-
Parameters
Returns string
Const untilValidResult
untilValidResult: object
predicate
predicate: function = ValueNodeType.is
Type declaration
-
-
Parameters
Returns boolean
errorMessage
-
Parameters
Returns string
Const untilValidStepResult
untilValidStepResult: object
predicate
predicate: function = ValueNodeType.is
Type declaration
-
-
Parameters
Returns boolean
errorMessage
-
Parameters
Returns string
Const untilValidTargetNode
untilValidTargetNode: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Muster ·

This is the monorepo for muster and muster-* packages.
Usage
The packages are published as separate NPM packages, so can be installed and imported separately.
npm install @dws/muster npm install @dws/muster-reactyarn add @dws/muster @dws/muster-react
import muster from '@dws/muster'; import { container } from '@dws/muster-react';Development
yarnSee CONTRIBUTING.md for details.
Licence
MIT